;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 141


SLOE   Jan ***, 1859 00:00:03  file DSK:CFNEW.SLO  --  of -- f2x

39m0155                               	
39m0155                               	
39m0155                               	;------------------------------------------------------------------------------
39m0155                               	;
39m0155                               	;       FooVision
39m0155                               	;
39m0155                               	;------------------------------------------------------------------------------
39m0155                               	.REPEAT VID [
39m0155                               	.INSERT VID.SLO
39m0155                               	];[
39m0155                               	.INSERT VID.SLO

^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 142


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

01m0001                               	COMMENT \               VID.SLO
01m0001                               	
01m0001                               	This is the microcode for vector display i/o.
01m0001                               	There are two basic macro instructions:
01m0001                               	        VIDIN AC,E:     770000,,0
01m0001                               	                        input from VID with i/o sub sel = ac
01m0001                               	                        to contents of effective address.
01m0001                               	        VIDOUT AC,E:    771000,,0
01m0001                               	                        output from contents of effective address
01m0001                               	                        to VID with i/o sub sel = ac
01m0001                               	
01m0001                               	These get dispatched to by 700 series iots
01m0001                               	(although the format is more like a non-iot instruction.)
01m0001                               	
01m0001                               	;OPDEF's for FooVision:
01m0001                               	OPDEF   VIDIN   [770000,,0]     ;In to CPU from FooVision (AC=MAPF)
01m0001                               	OPDEF   VIDOUT  [771000,,0]     ;Out from CPU to FooVision (AC=MAPF)
01m0001                               	OPDEF   VLDDAT  [VIDOUT 1,]     ;36 bit format or B,G,R 8 bits each
01m0001                               	OPDEF   VSYDAT  [VIDIN 1,]      ;Synthesize DATA (also to (E))
01m0001                               	OPDEF   VLDADR  [VIDOUT 2,]     ;16 bits right justified
01m0001                               	OPDEF   VSYADR  [VIDIN 2,]      ;Synthesize ADR (also to (E))
01m0001                               	OPDEF   VLDBAK  [VIDOUT 3,]     ;IOB 4-11 (of 36 bit word, 0=MSB)
01m0001                               	OPDEF   VOEVID  [VIDIN 4,]      ;36 bit format palette(3),(11*PIXEL(3))
01m0001                               	OPDEF   VOECOL  [VIDIN 5,]      ;B,G,R 8 bits each right justified
01m0001                               	OPDEF   VWECOL  [VIDIN 6,]      ;Write enable color map - (E) trashed
01m0001                               	OPDEF   VWEVID  [VIDIN 7,]      ;Write enable video buffer - (E) trashed
01m0001                               	OPDEF   VLDCOL  [VIDOUT 10,]    ;36 bit mask XORed with synthesized data
01m0001                               	OPDEF   VLDSIZ  [VIDOUT 11,]    ;OFFSET,,SIZE (in WDS/FLD (11 PXLS/WD))
01m0001                               	OPDEF   VLDCTR  [VIDOUT 12,]    ;B0=video resolution (vs. high res B/W)
01m0001                               	                                ;B1=add (don't overwrite)
01m0001                               	                                ;B2=carry
01m0001                               	                                ;B3=interlace
01m0001                               	                                ;B4=NTSC color
01m0001                               	OPDEF   VLDPIX  [VIDOUT 13,]    ;Inten.(3 bit),line (9 bit),,pixel(10 bit)
01m0001                               	OPDEF   VLDOFF  [VIDOUT 14,]    ;Y offset,,X offset
01m0001                               	OPDEF   VWEDIV  [VIDIN 16,]     ;Write enable divide table - (E) trashed
01m0001                               	OPDEF   VWENTS  [VIDIN 17,]     ;Write enable NTSC table - (E) trashed
01m0001                               	
01m0001                               	There are three additional instructions which simulate part of the
01m0001                               	Stanford-III vector display:
01m0001                               	
01m0001                               	OPDEF   DPYINI  [772000,,0]     ;Initialize display
01m0001                               	OPDEF   DPYOUT  [773000,,0]     ;Interpret Stanford-III display format
01m0001                               	OPDEF   DPYADD  [767000,,0]     ;Append Stanford-III display format
01m0001                               	
01m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 143


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

02m0001                               	        DPYINI POGB     ;Take a block of 64 words at E (which contain
02m0001                               	                        ;pointers to "shadow" pieces-of-glass, fonts,
02m0001                               	                        ;and various other state (used in interrupts)).
02m0001                               	                        ;Zero all POG lengths, and blank screen.
02m0001                               	
02m0001                               	POGB:   <POG0 LENGTH(15 bits RJ),,BEGINING-POG-BUFFER>
02m0001                               	POGB+1: <POG1 LENGTH(15 bits RJ),,BEGINING-POG-BUFFER>
02m0001                               	        ...
02m0001                               	POGB+15:<POG15 LENGTH(15 bits RJ),,BEGINING-POG-BUFFER>
02m0001                               	                                ;These are pointers to blocks of memory where
02m0001                               	                                ;the display list for the previous piece of
02m0001                               	                                ;glass is copied. This data is subtracted
02m0001                               	                                ;from the image by DPYOUT before adding the
02m0001                               	                                ;new display list.
02m0001                               	
02m0001                               	POGB+16:<POG0 XMAX,,XMIN>       ;Window boundaries
02m0001                               	POGB+17:<POG1 XMAX,,XMIN>
02m0001                               	        ...
02m0001                               	POGB+31:<POG15 XMAX,,XMIN>
02m0001                               	
02m0001                               	POGB+32:<POG0 YMAX,,YMIN>       ;Note: These are internal (- at top) coords.
02m0001                               	POGB+33:<POG1 YMAX,,YMIN>
02m0001                               	        ...
02m0001                               	POGB+47:<POG15 YMAX,,YMIN>
02m0001                               	
02m0001                               	POGB+48:<LAST COLOR,,LAST FONT> ;Pointers to fonts (2K each)
02m0001                               	POGB+49:<FONT 1>
02m0001                               	POGB+50:<FONT 2>
02m0001                               	        ...
02m0001                               	POGB+55:<FONT 7>
02m0001                               	
02m0001                               	POGB+56:<REMAINING LENGTH>      ;State for interrupt recovery
02m0001                               	POGB+57:<DISPLAY BUFFER POINTER,,PIECE OF GLASS POINTER>
02m0001                               	POGB+58:<MICRO RETURN ADDRESS>
02m0001                               	POGB+59:<COLOR MASK,,MASK>      ;Non VIC2 only
02m0001                               	POGB+60:<INTERLACED LINE 000000>;Non VIC2 only
02m0001                               	POGB+61:<X0,,X1>
02m0001                               	POGB+62:<Y0,,Y1>
02m0001                               	POGB+63:
02m0001                               	
02m0001                               	POGB+64:<AMEM[0]>
02m0001                               	POGB+65:<AMEM[1]>
02m0001                               	        ...
02m0001                               	POGB+71:<AMEM[7]>
02m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 144


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

03m0001                               	        DPYOUT POG,E    ;Similar to the stanford instruction. Takes
03m0001                               	       (DPYADD)         ;a pointer and length for the display list
03m0001                               	                        ;for the piece of glass and puts it on the
03m0001                               	                        ;screen, deleting (or adding to) the previous
03m0001                               	                        ;contents of that piece of glass.
03m0001                               	
03m0001                               	E:      <LENGTH>,,<BEGINING>
03m0001                               	
03m0001                               	Below are the two objects (vectors and characters) implemented from
03m0001                               	the Stanford-III display system:
03m0001                               	
03m0001                               	Long Word Vector:
03m0001                               	!00 10!11 21!22 24!25  27!28!29!30 31!32  35!
03m0001                               	!  X  !  Y  ! BRT ! SIZE !  !M !  T  ! 0110 !
03m0001                               	BRT(color):             SIZE:           M:              T:
03m0001                               	0=no change             0=no change     0=relative      0=visible
03m0001                               	1=white                 1=font 1        1=absolute      1=end point
03m0001                               	2=red                   .                               2=invisible
03m0001                               	3=yellow                .                               3=undefined
03m0001                               	4=green                 .                                 (end point)
03m0001                               	5=blue                  .
03m0001                               	6=magenta               .
03m0001                               	7=white(colored)        7=font 7
03m0001                               	
03m0001                               	CHaRacter:
03m0001                               	!00 06!07 13!14 20!21 27!28 34!35!
03m0001                               	! CH1 ! CH2 ! CH3 ! CH4 ! CH5 !1 !
03m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 145


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

04m0001                               	Vector algorithms:
04m0001                               	X(Y)=X(Y-1)+DXDY
04m0001                               	INTEN(Y,INT(X(Y)))=     3*(1-FRACT(X))          if A3DYDX GEQ 3
04m0001                               	                        3-A3DYDX*FRACT(X)       if A3DYDX < 3
04m0001                               	INTEN(Y,INT(X(Y))+1)=   3*FRACT(X)              if A3DYDX GEQ 3
04m0001                               	                        3-A3DYDX*(1-FRACT(X))   if A3DYDX < 3
04m0001                               	INTEN(Y,INT(X(Y))-K)=INTEN(Y,INT(X(Y))-(K-1))-A3DYDX
04m0001                               	INTEN(Y,INT(X(Y))+K)=INTEN(Y,INT(X(Y))+(K-1))-A3DYDX
04m0001                               	where:
04m0001                               	FRACT(X)        =fractional part of X
04m0001                               	INT(X)          =integer part of X
04m0001                               	X(Y)            =X(growing left to right) position as a function of
04m0001                               	                        Y(growing top to bottom)
04m0001                               	INTEN(Y,X)      =intensity as a function of position
04m0001                               	DXDY            =slope of X vs. Y
04m0001                               	A3DYDX          =three times the absolute value of the slope of Y vs. X
04m0001                               	
04m0001                               	The compromise color/grey level coding is as follows:
04m0001                               	
04m0001                               	per word:       0       1       2       3       4       5       6       7
04m0001                               	per pixel:
04m0001                               	        0       sync    black   black   black   black   black   black   black
04m0001                               	        1       sync    W 1     W 1     W 1     W 1     W 1     W 1     W 1
04m0001                               	        2       sync    W 2     W 2     W 2     W 2     W 2     W 2     W 2
04m0001                               	        3       sync    W 3     W 3     W 3     W 3     W 3     W 3     W 3
04m0001                               	        4       sync    W 4     R 3     Y 3     G 3     B 3     M 3     W 4
04m0001                               	        5       sync    W 5     R 3     Y 3     G 3     B 3     M 3     W 5
04m0001                               	        6       sync    W 6     R 3     Y 3     G 3     B 3     M 3     W 6
04m0001                               	        7       sync    W 7     R 3     Y 3     G 3     B 3     M 3     W 7
04m0001                               	
04m0001                               	B/W objects are clipped to intensity level 3. Colored objects are always
04m0001                               	either intensity 0 (blank) or intensity 4. This will make the overlapping
04m0001                               	of a colored object over one B/W object always come out colored and of the
04m0001                               	correct intensity.
04m0001                               	
04m0001                               	Note that two overlapping colored objects will cancel. Also note that a
04m0001                               	colored object overlapping two B/W objects which already overlap will not
04m0001                               	come out correctly colored. Finally, it is still only possible to have
04m0001                               	one color per word, i.e. two differently colored objects in the same word
04m0001                               	will overwrite eachother.
04m0001                               	
04m0001                               	
04m0001                               	This code will take interrupts correctly, but not map faults, since it is
04m0001                               	in general impossible to save all ones state so that one can restart.
04m0001                               	Specifically, there is no provision currently for saving the micro PC
04m0001                               	from which you faulted.
04m0001                               	
04m0001                               	To get around this failing, it is necessary to "touch" (i.e., reference)
04m0001                               	each page that the display list might require. This has an unplesant
04m0001                               	interaction with the scheduler in Tenex, which will frequently not allow
04m0001                               	the page touching loop to terminate (it has to get all the pages mapped
04m0001                               	before it can let the code run). To get around this, the code turns off the
04m0001                               	real time clock before touching and turns it back on after touching so that
04m0001                               	the code can interrupt as usual. This prevents scheduling due to interrupts
04m0001                               	from the real time clock during page validation cycles (map operations
04m0001                               	where the physical memory is actually there, but the map is invalid, usually
04m0001                               	due to map CONOs.)
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 146


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

04m0001                               	\
04m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 147


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

05m0001                               	;Note that VIDTAB (the dispatch table) must appear before VIDIN
05m0001                               	;and VIDOUT due to forward referencing problems.
05m0001                               	
05m0001       0	        %VIDFOO = 0
05m0001                               	
05m0001                               	VIDTAB:         ;dispatch table used by both VIDIN and VIDOUT.
05m0001                               	.REPEAT 16.
05m0001                               	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001                               	        %VIDFOO = %VIDFOO + 1
05m0001                               	]       
05m0001 06226 240144430571000440000000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       1	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06227 240144430571000440010000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       2	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06230 240144430571000440020000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       3	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06231 240144430571000440030000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       4	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06232 240144430571000440040000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       5	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06233 240144430571000440050000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       6	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06234 240144430571000440060000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       7	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06235 240144430571000440070000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       10	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06236 240144430571000440100000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       11	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06237 240144430571000440110000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       12	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06240 240144430571000440120000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       13	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06241 240144430571000440130000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       14	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06242 240144430571000440140000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       15	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06243 240144430571000440150000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       16	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06244 240144430571000440160000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       17	        %VIDFOO = %VIDFOO + 1
05m0001                               	]
05m0001 06245 240144430571000440170000	[       MAPF[%VIDFOO] D[IOD] DEST[HOLD] JUMP[VIDCOM] C800$
05m0001       20	        %VIDFOO = %VIDFOO + 1
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 148


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

05m0001                               	]       ;i/o sub sel = ac. input data and hold for memory write.
05m0001                               	
05m0001 06246 640700014171014620000000	VIDIN:  D[CONST (VIDTAB / 100)] ROT[6] DEST[Q] NORM$
05m0001                               	                ;form high order 6 bits of table dispatch.
05m0001 06247 640700014175000260000000	        D[CONST (VIDTAB \ 100)] ALU[DORQ] DEST[Q] NORM$
05m0001                               	                ;or in low order 6 bits of table dispatch.
05m0001 06250 440540034435032043400000	        D[IR] ROT[13.] MASK[4] ALU[D+Q] SDISP START-IN C600$
05m0001                               	                ;add ac field and dispatch. start input.
05m0001                               	
05m0001 06251 640702204571000440000000	VIDOUT: D[MEM] DEST[IOD] NORM$
05m0001                               	                ;put contents effective address into iod output register.
05m0001 06252 640700014171014620000000	        D[CONST (VIDTAB / 100)] ROT[6] DEST[Q] NORM$
05m0001                               	                ;form high order 6 bits of table dispatch.
05m0001 06253 640700014175000260000000	        D[CONST (VIDTAB \ 100)] ALU[DORQ] DEST[Q] NORM$
05m0001                               	                ;or in low order 6 bits of table dispatch.
05m0001 06254 440540034435032043600000	        D[IR] ROT[13.] MASK[4] ALU[D+Q] SDISP START-OUT C600$
05m0001                               	                ;add ac field and dispatch. start output.
05m0001                               	
05m0001                               	VIDCOM:         ;common completion.
05m0001 06255 451140034571020440002026	        D[IR] ROT[8]    COND[OBUS<0] JUMP[MAIN] C600$
05m0001                               	                ;if VIDOUT, done. jump main.
05m0001 06256 662104000571000440002032	        STRT-WRT MEMST$ [COND[-MA-AC] LBJUMP[MSMAIN] NORM ]
05m0001                               	                ;if VIDIN, write as in movem.
05m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 149


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

06m0001                               	;Main A-MEM:
06m0001       1	        INTEN,,FRACT    = 1     ;For storage of vector display word
06m0001       7	        POG,,POGB       = 7     ;Left by DPYINI
06m0001                               	
06m0001                               	.REPEAT XUCODE [
06m0001                               	        .USE[HIGHMEM]   ;If 8K u-mem present, put video code there.
06m0001                               	]
06m0001                               	[
06m0001                               	        .USE[HIGHMEM]    [ XLIST
06m0001                               	 LIST ];If 8K u-mem present, put video code there.
06m0001                               	]
06m0001                               	;This macro saves the address given as its argument so that returns
06m0001                               	;from interrupts can resume operation there. Jumps to VIDINT, which
06m0001                               	;saves AMEM, then goes to MAIN.
06m0001                               	
06m0001                               	;WARNING! WARNING !WARNING
06m0001                               	;THIS PIECE-OF-SHIT ASSEMBLER WON'T ACCEPT COMPOUND MACRO ARGUMENTS.
06m0001                               	;I.E., YOU MUST EVALUATE ARGUMENTS BEFORE INVOKING A MACRO.
06m0001                               	
06m0001                               	;ALSO, IF YOU CHANGE THE LENGTH OF THIS MACRO, REMEMBER TO ALTER THE
06m0001                               	;JUMP[. + 9]'S IN VIDRGT AND VIDLFT.
06m0001                               	
06m0001                               	.DEFINE VIDSAV[%ADR]
06m0001                               	[       D[CONST (%ADR / 10000)] ROT[12.] DEST[Q] NORM $
06m0001                               	                ;Q=high bit (SDISP loads all 16 bits)
06m0001                               	        D[CONST (77 & (%ADR / 100))] ROT[6] ALU[QORD] DEST[Q] NORM $
06m0001                               	                ;Q=next 6 ADR bits
06m0001                               	        D[CONST (%ADR \ 100)] ALU[QORD] DEST[HOLD] NORM $
06m0001                               	                ;Q=SAVE ADR
06m0001                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
06m0001                               	                ;Q=POGB
06m0001                               	        D[CONST 58.] ALU[Q+D] DEST[MA] STRT-WRT JUMP[VIDINT] NORM $
06m0001                               	                ;MA=POGB+58     write SAVE ADR
06m0001                               	]
06m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 150


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

07m0001                               	;DPYINI
07m0001                               	;Save the POG block pointer for use by DPYOUT.
07m0001 10353 640701614571000040000000	VIDDPI: D[CONST 4] DEST[DEV-ADR] NORM $
07m0001                               	                ;DEV-ADR=INTERRUPT
07m0001 10354 640702214571000003600000	        D[CONST 0] DEST[IOD] START-OUT NORM $
07m0001                               	                ;TURN OFF INTERRUPTS (SO WE DON'T GO TO THE SCHEDULER)
07m0001 10355 240700000571000440060000	        MAPF[6] C800 $
07m0001                               	                ;BIT 35 = ON/OFF
07m0001 10356 640701614571000360000000	        D[CONST 36] DEST[DEV-ADR] NORM $
07m0001                               	                ;DEV-ADR=36
07m0001 10357 640701634571000223000000	        D[IR] MASK[18.] DEST[POG,,POGB] DEST-A-MEM NORM $
07m0001                               	                ;POG,,POGB=0,,E
07m0001                               	
07m0001                               	;Zero all lengths.
07m0001 10360 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
07m0001                               	                ;Q=POGB.
07m0001 10361 640704400615000440000000	        ALU[0] DEST[HOLD] NORM $
07m0001                               	                ;HOLD=0
07m0001 10362 640724014435000700000000	        D[CONST 56.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
07m0001                               	                ;MA=POGB+56.    write (0) 
07m0001 10363 640746214571000170020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-WRT] D[CONST 15.] LLOAD NORM $
07m0001                               	                ;Touch          Loop 16 times
07m0001 10364 640720000555000440000000	VIDIN1: ALU[Q] DEST[MA] NORM $
07m0001                               	                ;MA=Q           read
07m0001 10365 640706000017000440020000	        MAPF[NORM-RD] ALU[Q+1] DEST[Q FIXMAC-MAPF-RD] CYLEN[FIXM] $
07m0001                               	                ;Q=Q+1          touch
07m0001 10366 640710004571006250000000	        D[MEM] ROT[3] MASK[21.] DEST[AR] NORM $
07m0001                               	                ;AR=BACKGROUND,LENGTH,,BEGINING LSH 3 MASK 21 (LENGTH=0)
07m0001 10367 640704200571102440000000	        D[AR] ROT[36. - 3] DEST[MEMSTO] NORM $
07m0001                               	                ;HOLD=BACKGROUND,0,,BEGINING    write
07m0001                               	
07m0001                               	;Initialize the remaining length counter for this piece of glass.
07m0001 10370 640710004531000220000000	        D[MEM] MASK[18.] ALU[D-1] DEST[AR] NORM $
07m0001                               	                ;AR=BEGINING POG-1
07m0001 10371 640720000531000440000000	        D[AR] ALU[D-1] DEST[MA] NORM $
07m0001                               	                ;MA=BEGINING -2  read max length
07m0001 10372 640700000571000440020000	        MAPF[NORM-RD] NORM $
07m0001                               	                ;WAIT
07m0001 10373 640704404571000440000000	        D[MEM] DEST[HOLD] NORM $
07m0001                               	                ;HOLD=MAX LENGTH        Sigh. HOLD and MEM really are different
07m0001 10374 640724000571000440000000	        D[AR] DEST[MA] STRT-WRT NORM $
07m0001                               	                ;MA=BEGINING-1  write remaining length
07m0001 10375 640246200571000440020364	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-WRT] LOOP[VIDIN1] CYLEN[FIXM] $
07m0001                               	                ;touch and loop
07m0001                               	
07m0001                               	;Turn interrupts back on.
07m0001 10376 640701614571000040000000	        D[CONST 4] DEST[DEV-ADR] NORM $
07m0001                               	                ;DEV-ADR=INTERRUPT
07m0001 10377 640702214571000013600000	        D[CONST 1] DEST[IOD] START-OUT NORM $
07m0001                               	                ;TURN ON INTERRUPTS
07m0001 10400 240700000571000440060000	        MAPF[6] C800 $
07m0001                               	                ;BIT 35 = ON/OFF
07m0001 10401 640701614571000360000000	        D[CONST 36] DEST[DEV-ADR] NORM $
07m0001                               	                ;DEV-ADR=36
07m0001                               	
07m0001                               	;Clear screen.
07m0001                               	        D[CONST 44] ROT[30.] DEST[IOD] START-OUT 
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 151


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

07m0001 10402 656142214571074443600000	                COND[HALF] JUMP[VIDNTR] NORM $
07m0001                               	                ;IOD=440000,,000000     Check HALF
07m0001 10403 240700014171014070120000	VIDHER: MAPF[12] D[CONST 7] ROT[6] DEST[Q] C800 $
07m0001                               	                ;VLDCTR (overwrite)     Q=7*64 (past vert. sync)
07m0001 10404 640710014571006360000000	        D[CONST 30.] ROT[3] DEST[AR] NORM $
07m0001                               	                ;AR=240. (major loops)
07m0001 10405 640740014571000710000000	VIDIN2: D[CONST 57.] LLOAD NORM $
07m0001                               	                ;Loop 58. times
07m0001 10406 640700014035000060000000	        D[CONST 6] ALU[Q+D] DEST[Q] NORM $
07m0001                               	                ;Q=Q+6 (past horiz. sync)
07m0001 10407 240702200555000443600000	VIDIN3: ALU[Q] DEST[IOD] START-OUT C800 $
07m0001                               	                ;IOD=Q
07m0001 10410 240700000571000440020000	        MAPF[2] C800 $
07m0001                               	                ;VLDADR
07m0001 10411 240702214571102073600000	        D[CONST 7] ROT[33.] DEST[IOD] START-OUT C800 $
07m0001                               	                ;IOD=700000,,000000
07m0001 10412 240700000571000443410000	        MAPF[1] START-IN C800 $
07m0001                               	                ;VLDDAT (blank)
07m0001 10413 240700000571000440070000	        MAPF[7]  C800 $
07m0001                               	                ;VWEVID
07m0001 10414 240700000571000440000000	        C800 $
07m0001                               	                ;WAIT
07m0001 10415 240702214435034013600000	        D[CONST 1] ROT[14.] ALU[Q+D] DEST[IOD] START-OUT C800 $
07m0001                               	                ;IOD=Q+1 FIELD
07m0001 10416 240700000571000440020000	        MAPF[2] C800 $
07m0001                               	                ;VLDADR
07m0001 10417 240702214571102073600000	        D[CONST 7] ROT[33.] DEST[IOD] START-OUT C800 $
07m0001                               	                ;IOD=700000,,000000
07m0001 10420 240700000571000443410000	        MAPF[1] START-IN C800 $
07m0001                               	                ;VLDDAT (blank)
07m0001                               	        MAPF[7] ALU[Q+1] DEST[Q]
07m0001 10421 241140000017000440070000	                COND[INTRPT] JUMP[VIDNTI] C800 $
07m0001                               	                ;VWEVID         Q=Q+1   If interrupt, save state
07m0001 10422 240240000571000440000407	VIDIN4: LOOP[VIDIN3] C800 $
07m0001                               	                ;loop
07m0001                               	        D[AR] ALU[D-1] DEST[AR]
07m0001 10423 470150000531000440000405	                COND[-OBUS=0] JUMP[VIDIN2] C600 $
07m0001                               	                ;AR=AR-1        if 0, done.
07m0001                               	
07m0001                               	;Done.
07m0001 10424 640141600615000442200350	        ALU[0] DEST[DEV-ADR] SPEC[CLR-HALF] JUMP[GOMAIN] NORM $
07m0001                               	                ;Reset device address, clear HALF
07m0001                               	
07m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 152


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

08m0001                               	;Interrupt init
08m0001 10425 640704400555000440000000	VIDNTI: ALU[Q] DEST[HOLD] NORM $
08m0001                               	                ;HOLD=Q
08m0001 10426 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
08m0001                               	                ;Q=POGB
08m0001 10427 640724014435014010000000	        D[CONST 1] ROT[6] ALU[Q+D] DEST[MA] STRT-WRT NORM $
08m0001                               	                ;MA=POGB+64.    write old Q
08m0001 10430 640706200571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-WRT] CYLEN[FIXM] $
08m0001                               	                ;TOUCH
08m0001 10431 640704400571000440000000	        D[AR] DEST[HOLD] NORM $
08m0001                               	                ;HOLD=AR
08m0001 10432 640724014437014010000000	        D[CONST 1] ROT[6] ALU[D+Q+1] DEST[MA] STRT-WRT NORM $
08m0001                               	                ;MA=POGB+65.    write old AR
08m0001 10433 640706200571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-WRT] CYLEN[FIXM] $
08m0001                               	                ;TOUCH
08m0001 10434 640700014171076010000000	        D[CONST 1] ROT[35. - 4] DEST[Q] NORM $
08m0001                               	                ;Q=BIT 4 ON
08m0001 10435 640704620531000440000000	        D[PC] ALU[D-1] DEST[PC] NORM $
08m0001                               	                ;PC=PC-1
08m0001 10436 640705420575000440000000	        D[PC] ALU[DORQ] DEST[CRYOV] NORM $
08m0001                               	                ;Set HALF flag
08m0001 10437 640141600615000440000350	        ALU[0] DEST[DEV-ADR] JUMP[GOMAIN] NORM $
08m0001                               	                ;Reset dev and disp to intrpt
08m0001                               	
08m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 153


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

09m0001                               	;Return from init interupt.
09m0001 10440 240700074171000220120000	VIDNTR: MAPF[12] D[10 + POG,,POGB] MASK[18.] DEST[Q] C800 $
09m0001                               	                ;VLDCTR         Q=POGB
09m0001 10441 640720014437014010000000	        D[CONST 1] ROT[6] ALU[D+Q+1] DEST[MA] NORM $
09m0001                               	                ;MA=POGB+65.    read old AR
09m0001                               	        MAPF[NORM-RD] D[CONST 30.] ROT[3] DEST[Q FIXMAC-MAPF-RD]
09m0001 10442 640706014171006360020000	                CYLEN[FIXM] $
09m0001                               	                ;TOUCH          Q=240.
09m0001                               	        D[MEM] MASK[18.] ALU[Q-D]
09m0001 10443 451140004477000220000403	                COND[OBUS<0] JUMP[VIDHER] C600 $
09m0001                               	                ;Check for half word error (i.e. HALF left from another inst)
09m0001 10444 640710004571000220000000	        D[MEM] MASK[18.] DEST[AR] NORM $
09m0001                               	                ;Restore AR
09m0001 10445 240700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] C800 $
09m0001                               	                ;Q=POGB
09m0001 10446 640720014435014010000000	        D[CONST 1] ROT[6] ALU[Q+D] DEST[MA] NORM $
09m0001                               	                ;MA=POGB+64.    read old Q
09m0001 10447 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
09m0001                               	                ;TOUCH
09m0001                               	        D[MEM] MASK[6] DEST[Q]
09m0001 10450 530140004171000060000000	                COND[-OBUS=0] JUMP[VIDNR1] C550 $
09m0001                               	                ;Old Q mod 6.
09m0001 10451 640700014171014010000000	        D[CONST 1] ROT[6] DEST[Q] NORM $
09m0001                               	                ;If Q=0, Q=64.
09m0001 10452 640740014537014010000000	VIDNR1: D[CONST 1] ROT[6] ALU[D-Q] LLOAD NORM $
09m0001                               	                ;Count=remaining till end of line
09m0001 10453 640140004171000440000422	        D[MEM] DEST[Q] JUMP[VIDIN4] NORM $
09m0001                               	                ;Restore Q and resume from interrupt
09m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 154


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

10m0001                               	;DPYOUT (DPYADD) main loop
10m0001 10454 640700014171076010000000	VIDDPA: D[CONST 1] ROT[35. - 4] DEST[Q] NORM $
10m0001                               	                ;Q=BIT 4 ON
10m0001 10455 640705420575000440000000	        D[PC] ALU[DORQ] DEST[CRYOV] NORM $
10m0001                               	                ;SET HALF FLAG
10m0001                               	
10m0001                               	;FooVision device address (also AMEM block)
10m0001 10456 640701614571000040000000	VIDDPO: D[CONST 4] DEST[DEV-ADR] NORM $
10m0001                               	                ;DEV-ADR=INTERRUPT
10m0001 10457 640702214571000003600000	        D[CONST 0] DEST[IOD] START-OUT NORM $
10m0001                               	                ;TURN OFF INTERRUPTS (SO WE DON'T GO TO THE SCHEDULER)
10m0001 10460 240700000571000440060000	        MAPF[6] C800 $
10m0001                               	                ;BIT 35 = ON/OFF
10m0001 10461 640701614571000360000000	        D[CONST 36] DEST[DEV-ADR] NORM $
10m0001                               	                ;DEV-ADR=36
10m0001                               	
10m0001                               	;Save AC=POG in AMEM
10m0001 10462 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10463 640710034571032040000000	        D[IR] ROT[13.] MASK[4] DEST[AR] NORM $
10m0001                               	                ;AR=POG=AC
10m0001 10464 640701600575044443000000	        D[AR] ROT[18.] ALU[DORQ] DEST[POG,,POGB] DEST-A-MEM NORM $
10m0001                               	                ;POG,,POGB=AC,,POGB
10m0001                               	
10m0001                               	;"Touch" the first and last words of the POG block, so we don't
10m0001                               	;have to worry about map faulting on them later.
10m0001 10465 640720074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q MA] NORM $
10m0001                               	                ;Q,MA=POGB
10m0001 10466 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH FIRST WORD
10m0001 10467 640710014531006110000000	        D[CONST 11] ROT[3] ALU[D-1] DEST[AR] NORM $
10m0001                               	                ;AR=71.
10m0001 10470 640720000435000440000000	        D[AR] ALU[D+Q] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+71.
10m0001 10471 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH LAST WORD
10m0001                               	
10m0001                               	;Touch E. If left half E (=length of display list)=0, don't bother to
10m0001                               	;touch display list.
10m0001 10472 640720034571000220000000	        D[IR] MASK[18.] DEST[MA] NORM $
10m0001                               	                ;MA=E
10m0001 10473 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH
10m0001 10474 640710004571000220000000	        D[MEM] MASK[18.] DEST[AR] NORM $
10m0001                               	                ;AR=BEGINING
10m0001 10475 510140004571000000200000	        D[MEM] SPEC[LEFT] COND[OBUS=0] JUMP[VIDTDE] C550 $
10m0001                               	                ;If LENGTH=0, don't touch (but do continue)
10m0001                               	
10m0001                               	;Touch the display list. Start with the first word, touch every
10m0001                               	;512.th word until run off end. Then touch last word.
10m0001 10476 640720000171000440000000	VIDTDL: D[AR] DEST[Q MA] NORM $
10m0001                               	                ;Q,MA=AR (initially begining of display list)
10m0001                               	        MAPF[NORM-RD] D[CONST 1] ROT[9.] ALU[Q+D]
10m0001 10477 640716014035022010020000	                DEST[AR Q FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;AR,Q=AR+1 PAGE         touch (post inc)
10m0001 10500 640720034571000220000000	        D[IR] MASK[18.] DEST[MA] NORM $
10m0001                               	                ;MA=E
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 155


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

10m0001 10501 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;WAIT
10m0001 10502 640700004077000220000000	        D[MEM] MASK[18.] ALU[Q-D] DEST[Q] NORM $
10m0001                               	                ;Q=AR-BEGINING
10m0001                               	        D[MEM] ROT[18.] MASK[18.] ALU[D-Q-1] DEST[Q]
10m0001 10503 471140004135044220000476	                COND[-OBUS<0] JUMP[VIDTDL] C600 $
10m0001                               	                ;Q=LENGTH-(AR-BEGINING)-1       if<0 done
10m0001 10504 640720000435000440000000	        D[AR] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=BEGINING+LENGTH-1
10m0001 10505 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH LAST PAGE
10m0001                               	
10m0001                               	;Touch the POG buffer for this POG. Same as for display list.
10m0001                               	;(POGn-2)=POG maximum length
10m0001                               	;(POGn-1)=POG words left
10m0001 10506 640700074171000220000000	VIDTDE: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10507 640720074435044040000000	        D[10 + POG,,POGB] ROT[18.] MASK[4] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+POG    read begining pog buffer
10m0001 10510 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;wait
10m0001 10511 640710004171000220000000	        D[MEM] MASK[18.] DEST[Q AR] NORM $
10m0001                               	                ;AR,Q=0,,BEGINING POG BUFFER
10m0001 10512 640720014477000020000000	        D[CONST 2] ALU[Q-D] DEST[MA] NORM $
10m0001                               	                ;MA=POGN-2      read maximum length
10m0001 10513 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH -2nd word
10m0001 10514 640710004575044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[AR] NORM $
10m0001                               	                ;AR=MAXIMUM LENGTH,,BEGINING POG
10m0001 10515 640700200571000443000000	        D[AR] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
10m0001                               	                ;INTEN,,FRACT=MAXIMUM LENGTH,,BEGINING POG
10m0001 10516 640720000171000440000000	VIDTNL: D[AR] DEST[Q MA] NORM $
10m0001                               	                ;Q,MA=AR
10m0001                               	        MAPF[NORM-RD] D[CONST 1] ROT[9.] ALU[Q+D]
10m0001 10517 640706014035022010020000	                DEST[Q FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;AR,Q=AR+1 PAGE         touch (post inc)
10m0001 10520 640710014477066010000000	        D[CONST 1] ROT[18. + 9.] ALU[Q-D] DEST[AR] NORM $
10m0001                               	                ;AR=AR+(-1000,,1000)
10m0001 10521 640700000171000000200000	        D[AR] SPEC[LEFT] DEST[Q] NORM $
10m0001                               	                ;Q=REMAINING LENGTH,,0
10m0001                               	        D[CONST 1] ROT[18.] ALU[Q-D]
10m0001 10522 471140014477044010000516	                COND[-OBUS<0] JUMP[VIDTNL] C600 $
10m0001                               	                ;If LENGTH LEQ 0, done
10m0001 10523 640700044131044170000000	        D[10 + INTEN,,FRACT] ROT[18.] MASK[15.] ALU[D-1] DEST[Q] NORM $
10m0001                               	                ;Q=LENGTH-1
10m0001 10524 640720044435000220000000	        D[10 + INTEN,,FRACT] MASK[18.] ALU[D+Q] DEST[MA] NORM $
10m0001                               	                ;MA=BEGINING+LENGTH-1
10m0001 10525 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH LAST WORD
10m0001                               	
10m0001                               	;Touch all 7 fonts. Same as above.
10m0001                               	VIDTNE:
10m0001 10526 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10527 640710014435000600000000	        D[CONST 48.] ALU[Q+D] DEST[AR] NORM $
10m0001                               	                ;AR=POGB+48
10m0001 10530 640740014571000060000000	        D[CONST 6] LLOAD NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 156


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

10m0001                               	                ;LOOP 7 TIMES
10m0001 10531 640730000433000440000000	VIDTFL: D[AR] ALU[D+1] DEST[MA AR] NORM $
10m0001                               	                ;MA,AR=AR+1
10m0001 10532 640700000571000440000000	        NORM $
10m0001                               	                ;WAIT
10m0001 10533 640720004171000220000000	        D[MEM] MASK[18.] DEST[MA Q] NORM $
10m0001                               	                ;MA,Q=FONT 1
10m0001 10534 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH PAGE
10m0001                               	.REPEAT 3
10m0001                               	[       D[CONST 1] ROT[9.] ALU[Q+D] DEST[MA Q] NORM $
10m0001                               	                ;MA,Q=Q+1 PAGE
10m0001                               	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH PAGE
10m0001                               	]
10m0001                               	
10m0001 10535 640720014035022010000000	[       D[CONST 1] ROT[9.] ALU[Q+D] DEST[MA Q] NORM $
10m0001                               	                ;MA,Q=Q+1 PAGE
10m0001 10536 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH PAGE
10m0001                               	]
10m0001 10537 640720014035022010000000	[       D[CONST 1] ROT[9.] ALU[Q+D] DEST[MA Q] NORM $
10m0001                               	                ;MA,Q=Q+1 PAGE
10m0001 10540 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH PAGE
10m0001                               	]
10m0001 10541 640720014035022010000000	[       D[CONST 1] ROT[9.] ALU[Q+D] DEST[MA Q] NORM $
10m0001                               	                ;MA,Q=Q+1 PAGE
10m0001 10542 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;TOUCH PAGE
10m0001 10543 640700014131022010000000	]       D[CONST 1] ROT[9.] ALU[D-1] DEST[Q] NORM $
10m0001                               	                ;Q=1 PAGE - 1 WORD
10m0001 10544 640720024435000440000000	        D[MA] ALU[D+Q] DEST[MA] NORM $
10m0001                               	                ;MA=LAST WORD OF FONT
10m0001 10545 640246000571000440020531	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] LOOP[VIDTFL] CYLEN[FIXM] $
10m0001                               	                ;TOUCH PAGE     LOOP
10m0001                               	
10m0001                               	;Turn interrupts back on.
10m0001 10546 640701614571000040000000	        D[CONST 4] DEST[DEV-ADR] NORM $
10m0001                               	                ;DEV-ADR=INTERRUPT
10m0001 10547 640702214571000013600000	        D[CONST 1] DEST[IOD] START-OUT NORM $
10m0001                               	                ;TURN ON INTERRUPTS
10m0001 10550 240700000571000440060000	        MAPF[6] C800 $
10m0001                               	                ;BIT 35 = ON/OFF
10m0001 10551 640701614571000360000000	        D[CONST 36] DEST[DEV-ADR] NORM $
10m0001                               	                ;DEV-ADR=36
10m0001                               	
10m0001                               	;If length rememaining not 0, return from interrupt.
10m0001 10552 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10553 640720014435000700000000	        D[CONST 56.] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+56.    read LENGTH REMAINING
10m0001 10554 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001 10555 530140004571000440000000	        D[MEM] COND[-OBUS=0] JUMP[VIDRET] C550 $
10m0001                               	                ;If LENGTH REMAINING NEQ 0, return from interrupt
10m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 157


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

10m0001                               	;Check HALF flag to see if DPYADD.
10m0001 10556 676140000571000440000000	        COND[-HALF] JUMP[VIDMHL] NORM $
10m0001                               	                ;If HALF, DPYADD
10m0001                               	
10m0001                               	;Form the display list and POG buffer pointers.
10m0001 10557 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10560 640720074435044040000000	        D[10 + POG,,POGB] ROT[18.] MASK[4] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+POG    read LENGTH,,BEGINING
10m0001 10561 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001 10562 640700004171000220000000	        D[MEM] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=0,,BEGINING
10m0001 10563 640700004035044170000000	        D[MEM] ROT[18.] MASK[15.] ALU[Q+D] DEST[Q] NORM $
10m0001                               	                ;Q=0,,BEGINING+LENGTH
10m0001 10564 640720034571000440000000	        D[IR] DEST[MA] NORM $
10m0001                               	                ;MA=E   read BEGINING
10m0001 10565 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;WAIT
10m0001 10566 640704404575044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[HOLD] NORM $
10m0001                               	                ;HOLD=DISP BEGINING,,POG BEGINING+LENGTH
10m0001 10567 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10570 640724014435000710000000	        D[CONST 57.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
10m0001                               	                ;MA=POGB+57.    write DISP BEGINING,,POG BEGINING
10m0001 10571 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001                               	
10m0001                               	;Get length of display list and load control register
10m0001                               	;with code for addition. Add to length in POG.
10m0001 10572 640720034571000220000000	        D[IR] MASK[18.] DEST[MA] NORM $
10m0001                               	                ;MA=E           read LENGTH
10m0001                               	        MAPF[NORM-RD] D[10 + POG,,POGB] MASK[18.] DEST[Q FIXMAC-MAPF-RD]
10m0001 10573 640706074171000220020000	                CYLEN[FIXM] $
10m0001                               	                ;Q=POGB
10m0001 10574 640714404571044170000000	        D[MEM] ROT[18.] MASK[15.] DEST[AR HOLD] NORM $
10m0001                               	                ;AR,HOLD=LENGTH
10m0001 10575 640724014435000700000000	        D[CONST 56.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
10m0001                               	                ;MA=POGB+56.    write LENGTH
10m0001 10576 640702214571074643620000	        MAPF[NORM-RD] D[CONST 64] ROT[30.] DEST[IOD] START-OUT NORM $
10m0001                               	                ;IOD=640000,,000000
10m0001 10577 640720074435044220120000	        MAPF[12] D[10 + POG,,POGB] ROT[18.] MASK[18.] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;VLDCTR (add)   MA=POGB+POG     read BACK,LENGTH,,BEGIN
10m0001 10600 640700000171044440020000	        MAPF[NORM-RD] D[AR] ROT[18.] DEST[Q] NORM $
10m0001                               	                ;Q=LENGTH,,0
10m0001 10601 640144204435000440000000	        D[MEM] ALU[D+Q] DEST[MEMSTO] JUMP[VIDMLL] NORM $
10m0001                               	                ;HOLD=BACK,LENGTH+LENGTH,,BEGIN write
10m0001                               	
10m0001                               	;This is the outermost loop. It is gone through twice, once with
10m0001                               	;first-half-done off subtracting the previous POG buffer, then with
10m0001                               	;first-half-done on adding the display list and copying into the
10m0001                               	;POG buffer.
10m0001                               	
10m0001                               	;Form the display list and POG buffer pointers.
10m0001 10602 640700074171000220000000	VIDMHL: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10603 640720074435044040000000	        D[10 + POG,,POGB] ROT[18.] MASK[4] ALU[Q+D] DEST[MA] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 158


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

10m0001                               	                ;MA=POGB+POG    read LENGTH,,BEGINING
10m0001 10604 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001 10605 640710004171000220000000	        D[MEM] MASK[18.] DEST[Q AR] NORM $
10m0001                               	                ;AR Q=0,,BEGINING
10m0001 10606 640720034571000440000000	        D[IR] DEST[MA] NORM $
10m0001                               	                ;MA=E   read BEGINING
10m0001 10607 640706000571000440020000	        MAPF[NORM-RD] DEST[FIXMAC-MAPF-RD] CYLEN[FIXM] $
10m0001                               	                ;WAIT
10m0001 10610 640704404575044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[HOLD] NORM $
10m0001                               	                ;HOLD=DISP BEGINING,,POG BEGINING
10m0001 10611 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10612 640724014435000710000000	        D[CONST 57.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
10m0001                               	                ;MA=POGB+57.    write DISP BEGINING,,POG BEGINING
10m0001                               	
10m0001                               	;Initialize the remaining length counter for this piece of glass.
10m0001 10613 640700000171000440020000	        MAPF[NORM-RD] D[AR] DEST[Q] NORM $
10m0001                               	                ;Q=BEGINING POG
10m0001 10614 640720014477000020000000	        D[CONST 2] ALU[Q-D] DEST[MA] NORM $
10m0001                               	                ;MA=BEGINING -2  read max length
10m0001 10615 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001 10616 640704404571000440000000	        D[MEM] DEST[HOLD] NORM $
10m0001                               	                ;HOLD=MAX LENGTH        Sigh. HOLD and MEM really are different
10m0001 10617 640724000531000440000000	        D[AR] ALU[D-1] DEST[MA] STRT-WRT NORM $
10m0001                               	                ;MA=BEGINING-1  write remaining length
10m0001                               	
10m0001                               	;Check for first half done.
10m0001 10620 656140000571000440020000	        MAPF[NORM-RD] COND[HALF] JUMP[VIDMHH] NORM $
10m0001                               	                ;IF -HALF:
10m0001                               	
10m0001                               	;If first half not done, get length of POG buffer and load the control
10m0001                               	;register with the code for subtraction.
10m0001 10621 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10622 640720074435044040000000	        D[10 + POG,,POGB] ROT[18.] MASK[4] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+POG    read LENGTH,,BEGINING
10m0001 10623 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001 10624 640704404571044170000000	        D[MEM] ROT[18.] MASK[15.] DEST[HOLD] NORM $
10m0001                               	                ;HOLD=LENGTH
10m0001 10625 640724014435000700000000	        D[CONST 56.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
10m0001                               	                ;MA=POGB+56.    write LENGTH
10m0001 10626 640702214571074743620000	        MAPF[NORM-RD] D[CONST 74] ROT[30.] DEST[IOD] START-OUT NORM $
10m0001                               	                ;IOD=740000,,000000
10m0001 10627 240140000571000440120000	        MAPF[12] JUMP[VIDMLL] C800 $
10m0001                               	                ;VLDCTR (subtract)
10m0001                               	
10m0001                               	;If first half done, get length of display list and load control register
10m0001                               	;with code for addition. Put length in POG.
10m0001 10630 640720034571000220000000	VIDMHH: D[IR] MASK[18.] DEST[MA] NORM $
10m0001                               	                ;MA=E           read LENGTH
10m0001                               	        MAPF[NORM-RD] D[10 + POG,,POGB] MASK[18.] DEST[Q FIXMAC-MAPF-RD]
10m0001 10631 640706074171000220020000	                CYLEN[FIXM] $
10m0001                               	                ;Q=POGB
10m0001 10632 640714404571044170000000	        D[MEM] ROT[18.] MASK[15.] DEST[AR HOLD] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 159


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

10m0001                               	                ;AR,HOLD=LENGTH
10m0001 10633 640724014435000700000000	        D[CONST 56.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
10m0001                               	                ;MA=POGB+56.    write LENGTH
10m0001 10634 640702214571074643620000	        MAPF[NORM-RD] D[CONST 64] ROT[30.] DEST[IOD] START-OUT NORM $
10m0001                               	                ;IOD=640000,,000000
10m0001 10635 640720074435044040120000	        MAPF[12] D[10 + POG,,POGB] ROT[18.] MASK[4] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;VLDCTR (add)   MA=POGB+POG     read BACK,LENGTH,,BEGIN
10m0001 10636 640700000171044440020000	        MAPF[NORM-RD] D[AR] ROT[18.] DEST[Q] NORM $
10m0001                               	                ;Q=LENGTH,,0
10m0001 10637 640710004571006250000000	        D[MEM] ROT[3] MASK[21.] DEST[AR] NORM $
10m0001                               	                ;AR=BACK,LENGTH,,BEGIN LSH3 ROT21 (LENGTH=0)
10m0001 10640 000704200575102440000000	        D[AR] ROT[36. - 3] ALU[DORQ] DEST[MEMSTO] $
10m0001                               	                ;HOLD=BACK,LENGTH,,BEGIN        write
10m0001                               	
10m0001                               	;This is the display list or POG buffer loop. It extracts words and
10m0001                               	;determines whether they are characters or vectors.
10m0001                               	
10m0001                               	;If length = 0, go to end of half-done loop.
10m0001 10641 640700074171000220000000	VIDMLL: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10642 640720014435000700000000	        D[CONST 56.] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+56.    read LENGTH
10m0001 10643 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;NORM
10m0001 10644 510140004571000220000000	        D[MEM] MASK[18.] COND[OBUS=0] JUMP[VIDMHE] C550 $
10m0001                               	                ;If LENGTH=0, end
10m0001                               	
10m0001                               	;Check and update remaining length.
10m0001 10645 640720074435044040000000	        D[10 + POG,,POGB] ROT[18.] MASK[4] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+POG    read length,,BEGINING
10m0001 10646 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001 10647 640720004531000220000000	        D[MEM] MASK[18.] ALU[D-1] DEST[MA] NORM $
10m0001                               	                ;MA=BEGINING-1  read length remaining
10m0001 10650 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001                               	        D[MEM] ALU[D-1] DEST[MEMSTO]
10m0001 10651 451144204531000440000000	                COND[OBUS<0] JUMP[VIDMHE] C600 $
10m0001                               	                ;HOLD=REMAINING LENGTH-1        write remaining length
10m0001                               	                ;If length remaining-1<0, end this half(add or sub)
10m0001                               	
10m0001                               	;Read pointers and chech half.
10m0001 10652 640720014435000710000000	        D[CONST 57.] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+57.    read DISP LIST PTR,,POG BUFF PTR
10m0001 10653 656140000571000440020000	        MAPF[NORM-RD] COND[HALF] JUMP[VIDMLH] NORM $
10m0001                               	                ;If -HALF
10m0001                               	
10m0001                               	;If first half not done, read from POG buffer.
10m0001 10654 640720004571000220000000	        D[MEM] MASK[18.] DEST[MA] NORM $
10m0001                               	                ;MA=POG BUFF PTR        read POG WORD
10m0001 10655 640140000571000440020000	        MAPF[NORM-RD] JUMP[VIDMLE] NORM $
10m0001                               	                ;WAIT
10m0001                               	
10m0001                               	;If first half done, read from display list and copy into POG buffer.
10m0001 10656 640720004571044220000000	VIDMLH: D[MEM] ROT[18.] MASK[18.] DEST[MA] NORM $
10m0001                               	                ;MA=DISP LIST PTR       read DISPLAY WORD
10m0001 10657 640700000571000440020000	        MAPF[NORM-RD] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 160


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

10m0001                               	                ;WAIT
10m0001 10660 640710004571000440000000	        D[MEM] DEST[AR] NORM $
10m0001                               	                ;AR=DISPLAY WORD
10m0001 10661 640720014435000710000000	        D[CONST 57.] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+57.    read DISP LIST PTR,,POG BUFF PTR
10m0001 10662 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001 10663 640700004171000220000000	        D[MEM] MASK[18.] DEST[Q]  NORM $
10m0001                               	                ;Q=POG BUFF PTR
10m0001 10664 640704400571000440000000	        D[AR] DEST[HOLD] NORM $
10m0001                               	                ;HOLD=DISPLAY WORD
10m0001 10665 640724000555000440000000	        ALU[Q] DEST[MA] STRT-WRT NORM $
10m0001                               	                ;MA=POG BUFF PTR        write DISPLAY WORD
10m0001 10666 640704400571000440020000	        MAPF[NORM-RD] D[AR] DEST[HOLD] NORM $
10m0001                               	                ;HOLD=DISPLAY WORD
10m0001                               	;;;Please note the above kludge. This is necessary because HOLD
10m0001                               	;;;forgets its data whenever MA changes, even on a write (contrary
10m0001                               	;;;to the explanation in the microcode manual).
10m0001                               	
10m0001                               	;Decode opcode of display word (character or vector).
10m0001 10667 640700204571000443000000	VIDMLE: D[MEM] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
10m0001                               	                ;INTEN,,FRACT=NEXT WORD
10m0001                               	        D[MEM] MASK[1]
10m0001 10670 530140004571000010000000	                COND[-OBUS=0] JUMP[VIDCHI] C550 $
10m0001                               	                ;If bit 35=1, character
10m0001 10671 640700004171000040000000	        D[MEM] MASK[4] DEST[Q] NORM $
10m0001                               	                ;Q=4 LSB'S
10m0001                               	        D[CONST 06] ALU[Q#D]
10m0001 10672 510140014735000060000000	                COND[OBUS=0] JUMP[VIDVCI] C550 $
10m0001                               	                ;If 4 lsb's=0110, vector
10m0001                               	
10m0001                               	;Decrement length, and increment pointers.
10m0001 10673 640700074171000220000000	VIDDON: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10674 640720014435000700000000	        D[CONST 56.] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+56.    read LENGTH
10m0001 10675 640700000571000440020000	        MAPF[NORM-RD] NORM $
10m0001                               	                ;WAIT
10m0001 10676 640704204531000440000000	        D[MEM] ALU[D-1] DEST[MEMSTO] NORM $
10m0001                               	                ;HOLD=LENGTH-1  write LENGTH
10m0001 10677 640720014435000710000000	        D[CONST 57.] ALU[Q+D] DEST[MA] NORM $
10m0001                               	                ;MA=POGB+57.    read DISP LIST PTR,,POG BUFF PTR
10m0001 10700 640700014171001000020000	        MAPF[NORM-RD] D[CONST 1,,1] DEST[Q] NORM $
10m0001                               	                ;Q=1,,1
10m0001 10701 640144204435000440000641	        D[MEM] ALU[D+Q] DEST[MEMSTO] JUMP[VIDMLL] NORM $
10m0001                               	                ;HOLD=DISP LIST PTR,,POG BUFF PTR + 1,,1        write
10m0001                               	
10m0001                               	;Zero length remaining (so won't try to recover from interrupt).
10m0001 10702 640704400615000440000000	VIDMHE: ALU[0] DEST[HOLD] NORM $
10m0001                               	                ;HOLD=0
10m0001 10703 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
10m0001                               	                ;Q=POGB
10m0001 10704 640724014435000700000000	        D[CONST 56.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
10m0001                               	                ;MA=POGB+56.    write LENGTH REMAINING
10m0001                               	
10m0001                               	;If first half done, terminate. If not, set HALF flag and loop
10m0001 10705 656140000571000440020000	        MAPF[NORM-RD] COND[HALF] JUMP[VIDEND] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 161


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

10m0001                               	                ;If HALF, end
10m0001 10706 640700014171076010000000	        D[CONST 1] ROT[35. - 4] DEST[Q] NORM $
10m0001                               	                ;Q=bit 4 on
10m0001 10707 640145420575000440000602	        D[PC] ALU[DORQ] DEST[CRYOV] JUMP[VIDMHL] NORM $
10m0001                               	                ;Set HALF flag and loop
10m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 162


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

11m0001                               	;Interrupt and End
11m0001                               	;Save AMEM and go to MAIN to take interrupt.
11m0001 10710 640144620531000440020000	VIDINT: MAPF[NORM-RD] D[PC] ALU[D-1] DEST[PC] JUMP[VIDSAM] NORM $
11m0001                               	                ;PC=PC-1
11m0001 10711 640700000571000442200000	VIDEND: SPEC[CLR-HALF] NORM $
11m0001                               	                ;Clear HALF
11m0001 10712 640700074171000220000000	VIDSAM: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
11m0001                               	                ;Q=POGB
11m0001 10713 640700014035014010000000	        D[CONST 1] ROT[6] ALU[Q+D] DEST[Q] NORM $
11m0001                               	                ;Q=POGB+64.
11m0001       0	        %VIDFOO = 0
11m0001                               	.REPEAT 8.
11m0001                               	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
11m0001                               	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001                               	        %VIDFOO = %VIDFOO + 1
11m0001                               	]
11m0001                               	
11m0001 10714 640704440571000440020000	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
11m0001 10715 640724014435000000000000	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001       1	        %VIDFOO = %VIDFOO + 1
11m0001                               	]
11m0001 10716 640704444571000440020000	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
11m0001 10717 640724014435000010000000	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001       2	        %VIDFOO = %VIDFOO + 1
11m0001                               	]
11m0001 10720 640704450571000440020000	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
11m0001 10721 640724014435000020000000	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001       3	        %VIDFOO = %VIDFOO + 1
11m0001                               	]
11m0001 10722 640704454571000440020000	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
11m0001 10723 640724014435000030000000	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001       4	        %VIDFOO = %VIDFOO + 1
11m0001                               	]
11m0001 10724 640704460571000440020000	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
11m0001 10725 640724014435000040000000	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001       5	        %VIDFOO = %VIDFOO + 1
11m0001                               	]
11m0001 10726 640704464571000440020000	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
11m0001 10727 640724014435000050000000	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001       6	        %VIDFOO = %VIDFOO + 1
11m0001                               	]
11m0001 10730 640704470571000440020000	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 163


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

11m0001 10731 640724014435000060000000	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001       7	        %VIDFOO = %VIDFOO + 1
11m0001                               	]
11m0001 10732 640704474571000440020000	[       MAPF[NORM-RD] D[10 + %VIDFOO] DEST[HOLD] NORM $
11m0001                               	                ;HOLD=AMEM[%VIDFOO]
11m0001 10733 640724014435000070000000	        D[CONST %VIDFOO] ALU[Q+D] DEST[MA] STRT-WRT NORM $
11m0001                               	                ;MA=POGB+64.+%VIDFOO    write
11m0001       10	        %VIDFOO = %VIDFOO + 1
11m0001 10734 640141600615000440020350	]       MAPF[NORM-RD] ALU[0] DEST[DEV-ADR] JUMP[GOMAIN] NORM $
11m0001                               	                ;Reset device address, dispatch to interrupt or next instr.
11m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 164


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

12m0001                               	;Recovery
12m0001                               	;Restore AMEM.
12m0001 10735 640700074171000220000000	VIDRET: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
12m0001                               	                ;Q=POGB
12m0001 10736 640700014035014010000000	        D[CONST 1] ROT[6] ALU[Q+D] DEST[Q] NORM $
12m0001                               	                ;Q=POGB+64.
12m0001       0	        %VIDFOO = 0
12m0001                               	.REPEAT 8.
12m0001                               	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001                               	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001                               	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001                               	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
12m0001                               	
12m0001 10737 640720014435000000000000	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001 10740 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 10741 640700004571000443000000	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001       1	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
12m0001 10742 640720014435000010000000	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001 10743 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 10744 640700204571000443000000	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001       2	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
12m0001 10745 640720014435000020000000	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001 10746 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 10747 640700404571000443000000	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001       3	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
12m0001 10750 640720014435000030000000	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001 10751 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 10752 640700604571000443000000	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001       4	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
12m0001 10753 640720014435000040000000	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001 10754 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 10755 640701004571000443000000	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001       5	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 165


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

12m0001 10756 640720014435000050000000	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001 10757 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 10760 640701204571000443000000	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001       6	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
12m0001 10761 640720014435000060000000	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001 10762 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 10763 640701404571000443000000	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001       7	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
12m0001 10764 640720014435000070000000	[       D[CONST %VIDFOO] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+64.+%VIDFOO    read
12m0001 10765 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 10766 640701604571000443000000	        D[MEM] DEST[%VIDFOO] DEST-A-MEM NORM $
12m0001                               	                ;AMEM[%VIDFOO]=MEM
12m0001       10	        %VIDFOO = %VIDFOO + 1
12m0001                               	]
12m0001                               	;Check for first half done.
12m0001                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q]
12m0001 10767 656140074171000220000000	                COND[HALF] JUMP[VIDRIH] NORM $
12m0001                               	                ;Q=POGB         If -HALF
12m0001                               	
12m0001                               	;If first half not done, default color = modified last color
12m0001                               	;and xor mask = -1.
12m0001 10770 640720014435000600000000	        D[CONST 48.] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+48.    read LAST COLOR
12m0001 10771 640710014531102010020000	        MAPF[NORM-RD] D[CONST 1] ROT[33.] ALU[D-1] DEST[AR] NORM $
12m0001                               	                ;AR=077777,,777777
12m0001 10772 640700004171000440000000	        D[MEM] DEST[Q] NORM $
12m0001                               	                ;Q=LAST COLOR,,LAST FONT
12m0001                               	        D[MEM] ROT[2] MASK[2]
12m0001 10773 510140004571004020000000	                COND[OBUS=0] JUMP[VIDRIM] C550 $
12m0001                               	                ;If color>1
12m0001 10774 640700014175102070000000	        D[CONST 7] ROT[33.] ALU[DORQ] DEST[Q] NORM $
12m0001                               	                ;Q=COLOR 7 (WHITE FROM COLOR)
12m0001                               	VIDRIM:
12m0001                               	.REPEAT VIC2 [
12m0001                               	        D[AR] ALU[DORQ] DEST[IOD] START-OUT NORM $
12m0001                               	                ;IOD=MODIFIED LAST COLOR 77777,,777777
12m0001                               	];VIC2
12m0001                               	.REPEAT 1 - VIC2 [
12m0001                               	        D[AR] ALU[DORQ] DEST[HOLD] NORM $
12m0001                               	                ;MEM=MODIFIED LAST COLOR 77777,,777777
12m0001                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
12m0001                               	                ;Q=POGB
12m0001                               	        D[CONST 59.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
12m0001                               	                ;MA=POGB+59     write <COLOR MASK,,MASK>
12m0001                               	        MAPF[NORM-RD] JUMP[VIDRIE] NORM $
12m0001                               	                ;WAIT
12m0001                               	];[
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 166


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

12m0001 10775 640704400575000440000000	        D[AR] ALU[DORQ] DEST[HOLD] NORM $
12m0001                               	                ;MEM=MODIFIED LAST COLOR 77777,,777777
12m0001 10776 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
12m0001                               	                ;Q=POGB
12m0001 10777 640724014435000730000000	        D[CONST 59.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
12m0001                               	                ;MA=POGB+59     write <COLOR MASK,,MASK>
12m0001 11000 640140000571000440020000	        MAPF[NORM-RD] JUMP[VIDRIE] NORM $
12m0001                               	                ;WAIT
12m0001                               	]1-VIC2
12m0001                               	
12m0001                               	;If first half done, default color = last color, and xor mask = 0.
12m0001 11001 640720014435000600000000	VIDRIH: D[CONST 48.] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+48.    read LAST COLOR
12m0001 11002 640710014531102010020000	        MAPF[NORM-RD] D[CONST 1] ROT[33.] ALU[D-1] DEST[AR] NORM $
12m0001                               	                ;AR=077777,,777777
12m0001 11003 640700004171000440000000	        D[MEM] DEST[Q] NORM $
12m0001                               	                ;Q=LAST COLOR,,LAST FONT
12m0001                               	.REPEAT VIC2 [
12m0001                               	        D[AR] ALU[-D&Q] DEST[IOD] START-OUT NORM $
12m0001                               	                ;IOD=LAST COLOR 00000,,000000
12m0001                               	];VIC2
12m0001                               	.REPEAT 1 - VIC2 [
12m0001                               	        D[AR] ALU[-D&Q] DEST[HOLD] NORM $
12m0001                               	                ;MEM=LAST COLOR 00000,,000000
12m0001                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
12m0001                               	                ;Q=POGB
12m0001                               	        D[CONST 59.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
12m0001                               	                ;MA=POGB+59     write <COLOR MASK,,MASK>
12m0001                               	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001                               	];[
12m0001 11004 640704400675000440000000	        D[AR] ALU[-D&Q] DEST[HOLD] NORM $
12m0001                               	                ;MEM=LAST COLOR 00000,,000000
12m0001 11005 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
12m0001                               	                ;Q=POGB
12m0001 11006 640724014435000730000000	        D[CONST 59.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
12m0001                               	                ;MA=POGB+59     write <COLOR MASK,,MASK>
12m0001 11007 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001                               	]1-VIC2
12m0001                               	
12m0001                               	;Dispatch to saved microcode address to resume from interrupt.
12m0001 11010 240700074171000220100000	VIDRIE: MAPF[10] D[10 + POG,,POGB] MASK[18.] DEST[Q] C800 $
12m0001                               	                ;VLDCOL         Q=POGB
12m0001 11011 640720014435000720000000	        D[CONST 58.] ALU[Q+D] DEST[MA] NORM $
12m0001                               	                ;MA=POGB+58.    read SAVE ADR
12m0001 11012 640700000571000440020000	        MAPF[NORM-RD] NORM $
12m0001                               	                ;WAIT
12m0001 11013 540540004571000440000000	        D[MEM] SDISP C500 $
12m0001                               	                ;Dispatch on SAVE ADR
12m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 167


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

13m0001                               	;Character A-MEM:
13m0001                               	
13m0001       0	        WORD,,PIXEL3    = 0
13m0001       1	        YSIZE-1,,FONTPTR = 1
13m0001       2	        XMAX,,XMIN      = 2
13m0001       3	        YMAX,,YMIN      = 3
13m0001       4	        COLOR           = 4
13m0001       5	        XSIZE3,,XSIZE   = 5
13m0001       6	        LINE,,BYTEPTR   = 6
13m0001       7	        POG,,POGB       = 7
13m0001                               	
13m0001                               	;Note: The zeroth word of the font contains HEIGHT,,WIDTH
13m0001                               	;for that font.
13m0001                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 168


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

14m0001                               	;Character body
14m0001                               	
14m0001                               	;Get initial word and 3*pixel.
14m0001 11014 640700074171000220000000	VIDCHI: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=POGB
14m0001 11015 640720014435000750000000	        D[CONST 61.] ALU[Q+D] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+61.    read X0,,X1
14m0001 11016 640700014131014050020000	        MAPF[NORM-RD] D[CONST 5] ROT[6] ALU[D-1] DEST[Q] NORM $
14m0001                               	                ;Q=319.
14m0001 11017 640710004435000220000000	        D[MEM] MASK[18.] ALU[D+Q] DEST[AR] NORM $
14m0001                               	                ;AR=X1+319. (0=left hand edge)
14m0001 11020 640710000171000220000000	        D[AR] MASK[18.] DEST[Q AR] NORM $
14m0001                               	                ;Q,AR=X1+319. (eliminate carry across halfwords)
14m0001 11021 640050000435002440000000	        D[AR] ROT[1] ALU[D+Q] DEST[AR] PUSHJ[VIDD33] NORM $
14m0001                               	                ;AR=3*(corrected X coordinate), divide by 33
14m0001 11022 640700004575044443000000	        D[MEM] ROT[18.] ALU[DORQ] DEST[WORD,,PIXEL3] DEST-A-MEM NORM $
14m0001                               	                ;WORD,,PIXEL3=QUOTIENT,,REMAINDER
14m0001                               	
14m0001                               	;Initialize line and byte pointers.
14m0001 11023 640720024433000440000000	        D[MA] ALU[D+1] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+62.    read Y0,,Y1
14m0001 11024 640700014171060040020000	        MAPF[NORM-RD] D[CONST 4] ROT[18. + 6] DEST[Q] NORM $
14m0001                               	                ;Q=256,,0
14m0001 11025 640700004035044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[D+Q] DEST[Q] NORM $
14m0001                               	                ;Q=Y1+256.,,0
14m0001 11026 640701414575000073000000	        D[CONST 7] ALU[DORQ] DEST[LINE,,BYTEPTR] DEST-A-MEM NORM $
14m0001                               	                ;LINE,,BYTEPTR=Y1+256.,,7
14m0001                               	
14m0001                               	;Form XMAX,,XMIN
14m0001 11027 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=POGB
14m0001 11030 640700074035044040000000	        D[10 + POG,,POGB] ROT[18.] MASK[4] ALU[Q+D] DEST[Q] NORM $
14m0001                               	                ;Q=POGB+POG
14m0001 11031 640720014435000200000000	        D[CONST 16.] ALU[Q+D] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+16.+POG        read XMAX,,XMIN
14m0001 11032 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11033 640700404571000443000000	        D[MEM] DEST[XMAX,,XMIN] DEST-A-MEM NORM $
14m0001                               	                ;XMAX,,XMIN
14m0001                               	
14m0001                               	;Form YMAX,,YMIN
14m0001 11034 640700024171000440000000	        D[MA] DEST[Q] NORM $
14m0001                               	                ;Q=MA
14m0001 11035 640720014435000200000000	        D[CONST 16.] ALU[D+Q] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+32.+POG        read YMAX,,YMIN
14m0001 11036 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11037 640700604571000443000000	        D[MEM] DEST[YMAX,,YMIN] DEST-A-MEM NORM $
14m0001                               	                ;YMAX,,YMIN
14m0001                               	
14m0001                               	;Test HALF flag.
14m0001                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q]
14m0001 11040 656140074171000220000000	                COND[HALF] JUMP[VIDCHH] NORM $
14m0001                               	                ;Q=POGB         if -HALF
14m0001                               	
14m0001                               	;If not HALF, subtract old image with color=last color.
14m0001 11041 640720014435000600000000	        D[CONST 48.] ALU[D+Q] DEST[MA] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 169


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

14m0001                               	                ;MA=POGB+48.    read LAST COLOR
14m0001 11042 640710014531102010020000	        MAPF[NORM-RD] D[CONST 1] ROT[33.] ALU[D-1] DEST[AR] NORM $
14m0001                               	                ;AR=077777,,777777
14m0001 11043 640700004171000440000000	        D[MEM] DEST[Q] NORM $
14m0001                               	                ;Q=LAST COLOR,,LAST FONT
14m0001                               	        D[MEM] ROT[2] MASK[2]
14m0001 11044 510140004571004020000000	                COND[OBUS=0] JUMP[VIDCHM] C550 $
14m0001                               	                ;If color>1
14m0001 11045 640700014175102070000000	        D[CONST 7] ROT[33.] ALU[DORQ] DEST[Q] NORM $
14m0001                               	                ;Q=COLOR 7 (WHITE FROM COLOR)
14m0001                               	VIDCHM:
14m0001 11046 640141000575000443000000	        D[AR] ALU[DORQ] DEST[COLOR] DEST-A-MEM JUMP[VIDSCL] NORM $
14m0001                               	                ;COLOR=modified last color 77777,,777777
14m0001                               	
14m0001                               	;If HALF, add new image with last color.
14m0001 11047 640720014435000600000000	VIDCHH: D[CONST 48.] ALU[D+Q] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+48.    read LAST COLOR
14m0001 11050 640710014531102010020000	        MAPF[NORM-RD] D[CONST 1] ROT[33.] ALU[D-1] DEST[AR] NORM $
14m0001                               	                ;AR=077777,,777777
14m0001 11051 640700004171000440000000	        D[MEM] DEST[Q] NORM $
14m0001                               	                ;Q=LAST COLOR,,LAST FONT
14m0001 11052 640701000675000443000000	        D[AR] ALU[-D&Q] DEST[COLOR] DEST-A-MEM NORM $
14m0001                               	                ;COLOR=LAST COLOR 00000,,000000
14m0001                               	
14m0001                               	;This is the character scanning loop.
14m0001                               	
14m0001                               	;Set up font pointer. Flush nulls.
14m0001 11053 640700074171000220000000	VIDSCL: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=POGB
14m0001 11054 640720014435000710000000	        D[CONST 57.] ALU[D+Q] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+57.    read DISPLAY BUFFER POINTER
14m0001 11055 656140000571000440020000	        MAPF[NORM-RD] COND[HALF] JUMP[VIDSC1] NORM $
14m0001                               	                ;If -HALF
14m0001 11056 640160004571000220000000	        D[MEM] MASK[18.] DEST[MA] JUMP[VIDSC2] NORM $
14m0001                               	                ;MA=POG PTR     read
14m0001 11057 640720004571044220000000	VIDSC1: D[MEM] ROT[18.] MASK[18.] DEST[MA] NORM $
14m0001                               	                ;MA=DISP PTR    read
14m0001 11060 640701270571000440020000	VIDSC2: MAPF[NORM-RD] D[10 + LINE,,BYTEPTR] DEST[ROTR] NORM $
14m0001                               	                ;ROTR=LINE,,BYTEPTR
14m0001                               	        D[MEM] ROT[R] MASK[7] DEST[AR]
14m0001 11061 510150004571200070000000	                COND[OBUS=0] JUMP[VIDSCN] C550 $
14m0001                               	                ;AR=ASCII       if 0, next character
14m0001 11062 640720014435000600000000	        D[CONST 48.] ALU[D+Q] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+48.    read LAST FONT
14m0001 11063 640700000171010440020000	        MAPF[NORM-RD] D[AR] ROT[4] DEST[Q] NORM $
14m0001                               	                ;Q=0,,ASCII*16.
14m0001 11064 640700204435000223000000	        D[MEM] MASK[18.] ALU[D+Q] DEST[YSIZE-1,,FONTPTR] DEST-A-MEM NORM $
14m0001                               	                ;YSIZE-1,,FONTPTR=0,,LAST FONT+ASCII*16.
14m0001                               	
14m0001                               	;Get width and 3*width of character.
14m0001 11065 640700044171000220000000	        D[10 + YSIZE-1,,FONTPTR] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=FONTPTR
14m0001 11066 640720014435000170000000	        D[CONST 15.] ALU[D+Q] DEST[MA] NORM $
14m0001                               	                ;MA=FONTPTR+15.         read YSIZE,,XSIZE
14m0001 11067 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11070 640710004171000220000000	        D[MEM] MASK[18.] DEST[AR Q] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 170


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

14m0001                               	                ;AR,Q=0,,XSIZE
14m0001 11071 640700000035044440000000	        D[AR] ROT[18.] ALU[D+Q] DEST[Q] NORM $
14m0001                               	                ;Q=XSIZE,,XSIZE
14m0001 11072 640701200435046443000000	        D[AR] ROT[18. + 1] ALU[D+Q] DEST[XSIZE3,,XSIZE] DEST-A-MEM NORM $
14m0001                               	                ;XSIZE3,,XSIZE=XSIZE*3,,XSIZE
14m0001                               	
14m0001                               	;Initialize YSIZE-1
14m0001 11073 640700004171000000200000	        D[MEM] SPEC[LEFT] DEST[Q] NORM $
14m0001                               	                ;Q=YSIZE,,0
14m0001 11074 640700044175000440000000	        D[10 + YSIZE-1,,FONTPTR] ALU[DORQ] DEST[Q] NORM $
14m0001                               	                ;Q=YSIZE,,FONTPTR
14m0001 11075 640700214477044013000000	        D[CONST 1] ROT[18.] ALU[Q-D] DEST[YSIZE-1,,FONTPTR] DEST-A-MEM NORM $
14m0001                               	                ;YSIZE-1,,FONTPTR
14m0001                               	
14m0001                               	;Increment position one character width (right or down).
14m0001 11076 640710004171000000200000	        D[MEM] SPEC[LEFT] DEST[Q AR] NORM $
14m0001                               	                ;AR,Q=YSIZE,,0
14m0001                               	        D[MEM] ROT[18.] SPEC[LEFT] ALU[Q-D]
14m0001 11077 451140004477044000200000	                COND[OBUS<0] JUMP[VIDCCS] C600 $
14m0001                               	                ;If YSIZE-XSIZE<0, sideways
14m0001                               	
14m0001                               	;Update normal X0,,X1.
14m0001 11100 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=POGB
14m0001 11101 640720014435000750000000	        D[CONST 61.] ALU[D+Q] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+61.    read X0,,X1
14m0001 11102 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11103 640700004171000220000000	        D[MEM] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=0,,X1
14m0001 11104 640710064435000220000000	        D[10 + XSIZE3,,XSIZE] MASK[18.] ALU[D+Q] DEST[AR] NORM $
14m0001                               	                ;AR=0,,X1+XSIZE
14m0001 11105 640700004171044000200000	        D[MEM] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
14m0001                               	                ;Q=X1,,0
14m0001 11106 640704200575000220000000	        D[AR] MASK[18.] ALU[DORQ] DEST[MEMSTO] NORM $
14m0001                               	                ;HOLD=X1,,X1+XSIZE      write X0,,X1
14m0001                               	
14m0001                               	;Update normal Y0,,Y1.
14m0001 11107 640720024433000440000000	        D[MA] ALU[D+1] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+62.    read Y0,,Y1
14m0001 11110 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11111 000700004171000220000000	        D[MEM] MASK[18.] DEST[Q] $
14m0001                               	                ;Q=0,,Y1
14m0001 11112 640144204575044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[MEMSTO] JUMP[VIDCCL] NORM $
14m0001                               	                ;HOLD=Y1,,Y1    write Y0,,Y1
14m0001                               	
14m0001                               	;Update sideways X0,,X1.
14m0001 11113 640700074171000220000000	VIDCCS: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=POGB
14m0001 11114 640720014435000750000000	        D[CONST 61.] ALU[D+Q] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+61.    read X0,,X1
14m0001 11115 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11116 000700004171000220000000	        D[MEM] MASK[18.] DEST[Q] $
14m0001                               	                ;Q=0,,X1
14m0001 11117 640704204575044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[MEMSTO] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 171


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

14m0001                               	                ;HOLD=X1,,X1    write X0,,X1
14m0001                               	
14m0001                               	;Update sidways Y0,,Y1.
14m0001 11120 640720024433000440000000	        D[MA] ALU[D+1] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+62.    read Y0,,Y1
14m0001 11121 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11122 640700004171000220000000	        D[MEM] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=0,,Y1
14m0001 11123 640710000477044440000000	        D[AR] ROT[18.] ALU[Q-D] DEST[AR] NORM $
14m0001                               	                ;AR=0,,Y1-YSIZE
14m0001 11124 640700004171044000200000	        D[MEM] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
14m0001                               	                ;Q=Y1,,0
14m0001 11125 640704200575000220000000	        D[AR] MASK[18.] ALU[DORQ] DEST[MEMSTO] NORM $
14m0001                               	                ;HOLD=Y1,,Y1-YSIZE      write Y0,,Y1
14m0001                               	
14m0001                               	;Check X limits.
14m0001 11126 640720024531000440000000	VIDCCL: D[MA] ALU[D-1] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+61             read X0,,X1
14m0001 11127 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11130 640700004171000000200000	        D[MEM] SPEC[LEFT] DEST[Q] NORM $
14m0001                               	                ;Q=X0,,0
14m0001                               	        D[10 + XMAX,,XMIN] ROT[18.] SPEC[LEFT] ALU[Q-D]
14m0001 11131 451140050477044000200000	                COND[OBUS<0] JUMP[VIDCHE] C600 $
14m0001                               	                ;if X0,,0-XMIN,,0<0 skip
14m0001 11132 640700064035044000200000	        D[10 + XSIZE3,,XSIZE] ROT[18.] SPEC[LEFT] ALU[D+Q] DEST[Q] NORM $
14m0001                               	                ;Q=X0,,0+XSIZE,,0
14m0001                               	        D[10 + XMAX,,XMIN] SPEC[LEFT] ALU[D-Q]
14m0001 11133 451140050537000000200000	                COND[OBUS<0] JUMP[VIDCHE] C600 $
14m0001                               	                ;if XMAX,,0-(X0+XSIZE),,0<0 skip
14m0001                               	
14m0001                               	;Check Y limits.
14m0001 11134 640720024433000440000000	        D[MA] ALU[D+1] DEST[MA] NORM $
14m0001                               	                ;MA=POGB+62             read Y0,,Y1
14m0001 11135 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0001                               	                ;WAIT
14m0001 11136 640700004171000000200000	        D[MEM] SPEC[LEFT] DEST[Q] NORM $
14m0001                               	                ;Q=Y0,,0
14m0001                               	        D[10 + YMAX,,YMIN] ROT[18.] SPEC[LEFT] ALU[Q-D]
14m0001 11137 451140054477044000200000	                COND[OBUS<0] JUMP[VIDCHE] C600 $
14m0001                               	                ;if Y0,,0-YMIN,,0<0 skip
14m0001 11140 640700044035000000200000	        D[10 + YSIZE-1,,FONTPTR] SPEC[LEFT] ALU[D+Q] DEST[Q] NORM $
14m0001                               	                ;Q=Y0,,0+YSIZE-1,,0
14m0001 11141 640700014035044010000000	        D[CONST 1] ROT[18.] ALU[D+Q] DEST[Q] NORM $
14m0001                               	                ;Q=Y0,,0+YSIZE,,0
14m0001                               	        D[10 + YMAX,,YMIN] SPEC[LEFT] ALU[D-Q]
14m0001 11142 451140054537000000200000	                COND[OBUS<0] JUMP[VIDCHE] C600 $
14m0001                               	                ;if YMAX,,0-(Y0+YSIZE),,0<0 skip
14m0001                               	
14m0001                               	;This is the scan line loop for characters.
14m0001                               	
14m0001                               	;Put up first word of this line for this character.
14m0001 11143 640700044171000220000000	VIDCHL: D[10 + YSIZE-1,,FONTPTR] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=FONTPTR
14m0001 11144 640720044435044220000000	        D[10 + YSIZE-1,,FONTPTR] ROT[18.] MASK[18.] ALU[D+Q] DEST[MA] NORM $
14m0001                               	                ;MA=FONTPTR+YSIZE-1     read DATA
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 172


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

14m0001 11145 640700014171000410020000	        MAPF[NORM-RD] D[CONST 33.] DEST[Q] NORM $
14m0001                               	                ;Q=33.
14m0001 11146 640701240477000220000000	        D[10 + WORD,,PIXEL3] MASK[18.] ALU[Q-D] DEST[ROTR] NORM $
14m0001                               	                ;ROTR=33.-PIXEL3
14m0001 11147 640701440477000220000000	        D[10 + WORD,,PIXEL3] MASK[18.] ALU[Q-D] DEST[MASKR] NORM $
14m0001                               	                ;MASKR=33.-PIXEL3
14m0001 11150 640044404571201000000000	        D[MEM] ROT[R] MASK[R] DEST[HOLD] PUSHJ[VIDPUT] NORM $
14m0001                               	                ;HOLD=DATA ROT (33.-PIXEL) MASK (33.-PIXEL)     do it
14m0001                               	
14m0001                               	;Determine if there is another word.
14m0001 11151 240700040171000220070000	        MAPF[7] D[10 + WORD,,PIXEL3] MASK[18.] DEST[Q] C800 $
14m0001                               	                ;Q=PIXEL3       VWEVID
14m0001 11152 640700064035044220000000	        D[10 + XSIZE3,,XSIZE] ROT[18.] MASK[18.] ALU[D+Q] DEST[Q] NORM $
14m0001                               	                ;Q=PIXEL3+XSIZE3
14m0001                               	        D[CONST 33.] ALU[D-Q]
14m0001 11153 471140014537000410000000	                COND[-OBUS<0] JUMP[VIDCHS] C600 $
14m0001                               	                ;If 33.-(PIXEL3+XSIZE3)<0
14m0001                               	
14m0001                               	;If there is a second word, put it up.
14m0001 11154 640700040171000440000000	        D[10 + WORD,,PIXEL3] DEST[Q] NORM $
14m0001                               	                ;Q=WORD,,PIXEL
14m0001 11155 640700014435044013000000	        D[CONST 1] ROT[18.] ALU[Q+D] DEST[WORD,,PIXEL3] DEST-A-MEM NORM $
14m0001                               	                ;Temporarally increment WORD
14m0001 11156 640720024571000440000000	        D[MA] DEST[MA] NORM $
14m0001                               	                ;Read line of data again. (Not enough state.)
14m0001 11157 640700014171000360000000	        D[CONST 30.] DEST[Q] NORM $
14m0001                               	                ;Q=30.
14m0001 11160 640701240477000220000000	        D[10 + WORD,,PIXEL3] MASK[18.] ALU[Q-D] DEST[ROTR] NORM $
14m0001                               	                ;ROTR=30.-PIXEL3
14m0001 11161 640710004571200410000000	        D[MEM] ROT[R] MASK[33.] DEST[AR] NORM $
14m0001                               	                ;AR=DATA ROT (30.-PIXEL3) MASK 33.
14m0001 11162 640700014171002410000000	        D[CONST 33.] ROT[1] DEST[Q] NORM $
14m0001                               	                ;Q=66.
14m0001 11163 640700040077000220000000	        D[10 + WORD,,PIXEL3] MASK[18.] ALU[Q-D] DEST[Q] NORM $
14m0001                               	                ;Q=66.-PIXEL3
14m0001 11164 640701464477044220000000	        D[10 + XSIZE3,,XSIZE] ROT[18.] MASK[18.] ALU[Q-D] DEST[MASKR] NORM $
14m0001                               	                ;MASKR=66.-PIXEL3-XSIZE3
14m0001 11165 640700000171000440000000	        D[AR] DEST[Q] NORM $
14m0001                               	                ;Q=DATA ROT(30.-PIXEL3) MASK(33.)
14m0001 11166 640044400675001000000000	        D[MASK R] ALU[-D&Q] DEST[HOLD] PUSHJ[VIDPUT] NORM $
14m0001                               	                ;HOLD=DATA ROT(30.-PIXEL3) MASK(66.-PIXEL3-XSIZE3)
14m0001 11167 640700040171000440070000	        MAPF[7] D[10 + WORD,,PIXEL3] DEST[Q] NORM $
14m0001                               	                ;Q=WORD,,PIXEL          VWEVID
14m0001 11170 640700014477044013000000	        D[CONST 1] ROT[18.] ALU[Q-D] DEST[WORD,,PIXEL3] DEST-A-MEM NORM $
14m0001                               	                ;Redecrement WORD
14m0001                               	
14m0001                               	;Check for last scan line of character (also interrupts).
14m0001 11171 240700044171000440070000	VIDCHS: MAPF[7] D[10 + YSIZE-1,,FONTPTR] DEST[Q] C800 $
14m0001                               	                ;Q=YSIZE-1,,FONTPTR     VWEVID
14m0001                               	        D[CONST 1] ROT[18.] ALU[Q-D] DEST[YSIZE-1,,FONTPTR] DEST-A-MEM
14m0001 11172 451140214477044013000000	                COND[OBUS<0] JUMP[VIDCHE] C600 $
14m0001                               	                ;If YSIZE-1<0, done
14m0001 11173 661140000571000440001143	        COND[-INTRPT] JUMP[VIDCHL] NORM $
14m0001                               	                ;If no interrupt, loop
14m0001                               	        VIDSAV[VIDCHL]
14m0001                               	
14m0001 11174 640700014171030010000000	[       D[CONST (VIDCHL / 10000)] ROT[12.] DEST[Q] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 173


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

14m0001                               	                ;Q=high bit (SDISP loads all 16 bits)
14m0001 11175 640700014175014110000000	        D[CONST (77 & (VIDCHL / 100))] ROT[6] ALU[QORD] DEST[Q] NORM $
14m0001                               	                ;Q=next 6 ADR bits
14m0001 11176 640704414575000430000000	        D[CONST (VIDCHL \ 100)] ALU[QORD] DEST[HOLD] NORM $
14m0001                               	                ;Q=SAVE ADR
14m0001 11177 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
14m0001                               	                ;Q=POGB
14m0001 11200 640164014435000720000710	        D[CONST 58.] ALU[Q+D] DEST[MA] STRT-WRT JUMP[VIDINT] NORM $
14m0001                               	                ;MA=POGB+58     write SAVE ADR
14m0002                               	]               ;Interrupt
14m0002                               	
14m0002                               	;Increment position one character width (right or down).
14m0002 11201 640700044171000220000000	VIDCHE: D[10 + YSIZE-1,,FONTPTR] MASK[18.] DEST[Q] NORM $
14m0002                               	                ;Q=PONTPTR
14m0002 11202 640720014435000170000000	        D[CONST 15.] ALU[Q+D] DEST[MA] NORM $
14m0002                               	                ;MA=POGB+15.    read YSIZE,,XSIZE
14m0002 11203 640700000571000440020000	        MAPF[NORM-RD] NORM $
14m0002                               	                ;WAIT
14m0002 11204 640700004171000000200000	        D[MEM] SPEC[LEFT] DEST[Q] NORM $
14m0002                               	                ;Q=YSIZE,,0
14m0002                               	        D[MEM] ROT[18.] SPEC[LEFT] ALU[Q-D]
14m0002 11205 451140004477044000200000	                COND[OBUS<0] JUMP[VIDCE2] C600 $
14m0002                               	                ;If YSIZE-XSIZE<0, sideways
14m0002                               	
14m0002 11206 640700064171000000200000	        D[10 + XSIZE3,,XSIZE] SPEC[LEFT] DEST[Q] NORM $
14m0002                               	                ;Q=XSIZE3,,0
14m0002 11207 640700040035044000200000	        D[10 + WORD,,PIXEL3] ROT[18.] SPEC[LEFT] ALU[Q+D] DEST[Q] NORM $
14m0002                               	                ;Q=PIXEL3+XSIZE3,,0
14m0002                               	        D[CONST 33.] ROT[18.] ALU[Q-D]
14m0002 11210 451140014477044410000000	                COND[OBUS<0] JUMP[VIDCE1] C600 $
14m0002                               	                ;If PIXEL3+XSIZE3-33.<0 skip
14m0002 11211 640700014077044410000000	        D[CONST 33.] ROT[18.] ALU[Q-D] DEST[Q] NORM $
14m0002                               	                ;Q=PIXEL3+XSIZE3-33.,,0
14m0002 11212 640700000017000440000000	        ALU[Q+1] DEST[Q] NORM $
14m0002                               	                ;Q=PIXEL3+XSIZE3-33.,,1
14m0002 11213 640710000555000440000000	VIDCE1: ALU[Q] DEST[AR] NORM $
14m0002                               	                ;AR=NEW PIXEL3,,WORD OFFSET
14m0002 11214 640700040171000000200000	        D[10 + WORD,,PIXEL3] SPEC[LEFT] DEST[Q] NORM $
14m0002                               	                ;Q=WORD,,0
14m0002                               	        D[AR] ROT[18.] ALU[D+Q] DEST[WORD,,PIXEL3] DEST-A-MEM
14m0002 11215 640140000435044443000000	                JUMP[VIDSCN] NORM $
14m0002                               	                ;WORD,,PIXEL3=WORD+OFFSET,,NEW PIXEL3
14m0002                               	
14m0002 11216 640700070171000440000000	VIDCE2: D[10 + LINE,,BYTEPTR] DEST[Q] NORM $
14m0002                               	                ;Q=LINE,,BYTEPTR
14m0002 11217 640700004077000000200000	        D[MEM] SPEC[LEFT] ALU[Q-D] DEST[Q] NORM $
14m0002                               	                ;Q=LINE-YSIZE,,BYTEPTR
14m0002 11220 640701400555000443000000	        ALU[Q] DEST[LINE,,BYTEPTR] DEST-A-MEM NORM $
14m0002                               	                ;LINE-YSIZE,,BYTEPTR
14m0002                               	        
14m0002                               	
14m0002                               	;Increment byte pointer for next character.
14m0002 11221 640700070171000440000000	VIDSCN: D[10 + LINE,,BYTEPTR] DEST[Q] NORM $
14m0002                               	                ;Q=LINE,,BYTEPTR
14m0002 11222 640711414435000073000000	        D[CONST 7] ALU[Q+D] DEST[AR LINE,,BYTEPTR] DEST-A-MEM NORM $
14m0002                               	                ;AR,LINE,,BYTEPTR=LINE,,BYTEPTR+7
14m0002 11223 640700000171044000200000	        D[AR] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 174


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

14m0002                               	                ;Q=BYTEPTR+7,,0
14m0002                               	        D[CONST 36.] ROT[18.] ALU[D-Q]
14m0002 11224 471140014537044440001053	                COND[-OBUS<0] JUMP[VIDSCL] C600 $
14m0002                               	                ;If 36.,,0-BYTEPTR+7,,0<0
14m0002 11225 640140000571000440000673	        JUMP[VIDDON] NORM $
14m0002                               	                ;Done
14m0002                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 175


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

15m0002                               	;Divide by 33. (Efficient till 2048./33.)
15m0002                               	
15m0002                               	;AR=DIVIDEND
15m0002                               	
15m0002 11226 640704400171076370000000	VIDD33: D[AR] ROT[36. - 5] MASK[36. - 5] DEST[Q HOLD] NORM $
15m0002                               	                ;Q,HOLD=QUOTIENT=AR/32.
15m0002 11227 640700004035012440000000	VID33L: D[MEM] ROT[5] ALU[D+Q] DEST[Q] NORM $
15m0002                               	                ;Q=33*QUOTIENT
15m0002                               	        D[AR] ALU[D-Q] DEST[Q]
15m0002 11230 471300000137000440000000	                COND[-OBUS<0] POPJ C600 $
15m0002                               	                ;Q=REMAINDER, if < 0
15m0002 11231 640144404131000440001227	        D[MEM] ALU[D-1] DEST[Q HOLD] JUMP[VID33L] NORM $
15m0002                               	                ;Q,HOLD=QUOTIENT-1      loop
15m0002                               	
15m0002                               	;MEM=QUOTIENT
15m0002                               	;Q=REMAINDER
15m0002                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 176


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

16m0002                               	;Put up one word of video
16m0002                               	
16m0002                               	;MEM=DATA
16m0002                               	
16m0002 11232 640700070171044220000000	VIDPUT: D[10 + LINE,,BYTEPTR] ROT[18.] MASK[18.] DEST[Q] NORM $
16m0002                               	                ;Q=0,,LINE
16m0002 11233 640710044477044220000000	        D[10 + YSIZE-1,,FONTPTR] ROT[18.] MASK[18.] ALU[Q-D] DEST[AR] NORM $
16m0002                               	                ;AR=0,,LINE-(YSIZE-1)
16m0002 11234 640700000171012440000000	        D[AR] ROT[5] DEST[Q] NORM $
16m0002                               	                ;Q=0 LINE 00000
16m0002 11235 640700014275012010000000	        D[CONST 1] ROT[5] ALU[-D&Q] DEST[Q] NORM $
16m0002                               	                ;Q=0 LINE/2 000000
16m0002                               	        D[AR] ROT[36. - 1]
16m0002 11236 531140000571106440000000	                COND[-OBUS<0] JUMP[VIDPT1] C550 $
16m0002                               	                ;IF LSB[LINE]=1
16m0002 11237 640700014175034010000000	        D[CONST 1] ROT[14.] ALU[QORD] DEST[Q] NORM $
16m0002                               	                ;Q=ODD[LINE] LINE/2 000000
16m0002 11240 640700040175044060000000	VIDPT1: D[10 + WORD,,PIXEL3] ROT[18.] MASK[6] ALU[QORD] DEST[Q] NORM $
16m0002                               	                ;Q=ODD[LINE] LINE/2 WORD (=interlaced address)
16m0002                               	
16m0002 11241 640700014035014070000000	        D[CONST 7] ROT[6] ALU[Q+D] DEST[Q] NORM $
16m0002                               	                ;Q=ADR+7*64.
16m0002 11242 640702214435000063600000	        D[CONST 6] ALU[Q+D] DEST[IOD] START-OUT NORM $
16m0002                               	                ;IOD=ADR+7 lines, 6 words
16m0002                               	
16m0002 11243 240700004171000410020000	        MAPF[2] D[MEM] MASK[33.] DEST[Q] C800 $
16m0002                               	                ;VLDADR Q=DATA
16m0002                               	        D[10 + COLOR] ROT[2] MASK[2]
16m0002 11244 270040060571004020000000	                COND[-OBUS=0] PUSHJ[VIDCOL] C800 $
16m0002                               	                ;If bit(s) 0 or 1 of color on, "color" the word
16m0002 11245 240702260735000443600000	        D[10 + COLOR] ALU[D#Q] DEST[IOD] START-OUT C800 $
16m0002                               	                ;IOD=DATA XOR COLOR
16m0002 11246 240300000571000443410000	        MAPF[1] START-IN POPJ C800 $
16m0002                               	                ;VLDDAT (next line must have MAPF[7] ... C800)
16m0002                               	
16m0002                               	;Make the contents of Q be a colored data word.
16m0002                               	;If <2 make it 0, else make it 4.
16m0002 11247 640710000555000440000000	VIDCOL: ALU[Q] DEST[AR] NORM $
16m0002                               	                ;COPY Q
16m0002 11250 640700000175002440000000	        D[AR] ROT[1] ALU[DORQ] DEST[Q] NORM $
16m0002                               	                ;The 4 bit in each pixel is 1 if either the 4 or 2 bits were 1.
16m0002 11251 640700014275000330000000	        D[CONST 33] ALU[-D&Q] DEST[Q] NORM $
16m0002                               	                ;Zero the 2 and 1 bits.
16m0002 11252 640700014275014330000000	        D[CONST 33] ROT[6] ALU[-D&Q] DEST[Q] NORM $
16m0002                               	                ;Zero the 2 and 1 bits.
16m0002 11253 640700014275030330000000	        D[CONST 33] ROT[12.] ALU[-D&Q] DEST[Q] NORM $
16m0002                               	                ;Zero the 2 and 1 bits.
16m0002 11254 640700014275044330000000	        D[CONST 33] ROT[18.] ALU[-D&Q] DEST[Q] NORM $
16m0002                               	                ;Zero the 2 and 1 bits.
16m0002 11255 640700014275060330000000	        D[CONST 33] ROT[24.] ALU[-D&Q] DEST[Q] NORM $
16m0002                               	                ;Zero the 2 and 1 bits.
16m0002 11256 640300014275074730000000	        D[CONST 73] ROT[30.] ALU[-D&Q] DEST[Q] POPJ NORM $
16m0002                               	                ;Zero the 2 and 1 bits.
16m0002                               	
16m0002                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 177


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

17m0002                               	;Vector A-MEM:
17m0002                               	
17m0002       0	        PIXEL,,FRACT    = 0
17m0002       1	        INTEN,,FRACT    = 1
17m0002       2	        XMAX,,XMIN      = 2
17m0002       3	        YMAX,,YMIN      = 3
17m0002       4	        DXDY,,FRACT     = 4
17m0002       5	        A3DYDX,,FRACT   = 5
17m0002       6	        OFFSET,,LINE    = 6
17m0002       7	        POG,,POGB       = 7
17m0002                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 178


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

18m0002                               	;Paint line left
18m0002                               	.DEFINE VIDLFT[]
18m0002                               	[       D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
18m0002                               	                ;Q=0,,LINE
18m0002                               	        ALU[Q] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
18m0002                               	                ;OFFSET,,LINE=0,,LINE
18m0002                               	
18m0002                               	        PUSHJ[VIDDT1] NORM $
18m0002                               	                ;Do it
18m0002                               	
18m0002                               	        MAPF[7] D[10 + INTEN,,FRACT] DEST[Q] C800 $
18m0002                               	                ;Q=INTEN,,FRACT         VWEVID
18m0002                               	        D[10 + A3DYDX,,FRACT] ALU[Q-D] DEST[Q] NORM $
18m0002                               	                ;Q=INTEN,,FRACT-A3DYDX,,FRACT
18m0002                               	        ALU[Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
18m0002                               	                ;AMEM[1]=INTEN,,FRACT-A3DYDX,,FRACT
18m0002                               	        D[CONST 4] ROT[15.] ALU[Q-D-1]
18m0002                               	                COND[OBUS<0] JUMP[. + 9] C600 $
18m0002                               	                ;If INTEN,,FRACT-0,,377777<0, done.
18m0002                               	
18m0002                               	        D[10 + OFFSET,,LINE] DEST[Q] NORM $
18m0002                               	                ;Q=OFFSET,,LINE
18m0002                               	        D[CONST 1] ROT[18.] ALU[Q-D] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
18m0002                               	                ;OFFSET-1,,LINE
18m0002                               	
18m0002                               	        COND[-INTRPT] JUMP[. - 7] NORM $
18m0002                               	                ;Loop if no interrupt
18m0002                               	        %VIDFOO = (. - 8)       ;NOTE: THIS FORCES EVALUATION BEFORE
18m0002                               	        VIDSAV[%VIDFOO]         ;       THE MACRO GETS ITS ARGUMENT.
18m0002                               	                ;Interrupt
18m0002                               	]
18m0002                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 179


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

19m0002                               	;Paint line right
19m0002                               	.DEFINE VIDRGT[]
19m0002                               	[       D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
19m0002                               	                ;Q=0,,LINE
19m0002                               	        D[CONST 1] ROT[18.] ALU[QORD] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
19m0002                               	                ;OFFSET,,LINE=1,,LINE
19m0002                               	
19m0002                               	        PUSHJ[VIDDT1] NORM $
19m0002                               	                ;Do it (loop to here)
19m0002                               	
19m0002                               	        MAPF[7] D[10 + INTEN,,FRACT] DEST[Q] C800 $
19m0002                               	                ;Q=INTEN,,FRACT         VWEVID
19m0002                               	        D[10 + A3DYDX,,FRACT] ALU[Q-D] DEST[Q] NORM $
19m0002                               	                ;Q=INTEN,,FRACT-A3DYDX,,FRACT
19m0002                               	        ALU[Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
19m0002                               	                ;AMEM[1]=INTEN,,FRACT-A3DYDX,,FRACT
19m0002                               	        D[CONST 4] ROT[15.] ALU[Q-D-1]
19m0002                               	                COND[OBUS<0] JUMP[. + 9] C600 $
19m0002                               	                ;If INTEN,,FRACT-0,,377777<0, done.
19m0002                               	
19m0002                               	        D[10 + OFFSET,,LINE] DEST[Q] NORM $
19m0002                               	                ;Q=OFFSET,,LINE
19m0002                               	        D[CONST 1] ROT[18.] ALU[Q+D] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
19m0002                               	                ;OFFSET+1,,LINE
19m0002                               	
19m0002                               	        COND[-INTRPT] JUMP[. - 7] NORM $
19m0002                               	                ;Loop if no interrupt
19m0002                               	        %VIDFOO = (. - 8)       ;NOTE: THIS FORCES EVALUATION BEFORE
19m0002                               	        VIDSAV[%VIDFOO]         ;       THE MACRO GETS ITS ARGUMENT.
19m0002                               	                ;Interrupt
19m0002                               	]
19m0002                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 180


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

20m0002                               	;Vector Body
20m0002                               	;Extract X field from vector word (extending sign).
20m0002                               	;Shift right 1.
20m0002 11257 640710014531020010000000	VIDVCI: D[CONST 1] ROT[8.] ALU[D-1] DEST[AR] NORM $
20m0002                               	                ;AR=377
20m0002 11260 640700044171024120000000	        D[10 + INTEN,,FRACT] ROT[10.] MASK[10.] DEST[Q] NORM $
20m0002                               	                ;Q=X
20m0002                               	        D[CONST 1] ROT[9.] ALU[D&Q]
20m0002 11261 510140014635022010000000	                COND[OBUS=0] JUMP[VIDVC1] C550 $
20m0002                               	                ;IF SIGN=1
20m0002 11262 640700000175024440000000	        D[AR] ROT[10.] ALU[DORQ] DEST[Q] NORM $
20m0002                               	                ;Q=0,,776 X
20m0002 11263 640700400555000443000000	VIDVC1: ALU[Q] DEST[XMAX,,XMIN] DEST-A-MEM NORM $
20m0002                               	                ;XMAX,,XMIN=0,,X
20m0002                               	
20m0002                               	;Extract Y field from vector word (extending sign). Note the sign change.
20m0002 11264 640710044473052120000000	        D[10 + INTEN,,FRACT] ROT[21.] MASK[10.] ALU[0-D] DEST[AR] NORM $
20m0002                               	                ;Q=-Y
20m0002 11265 640700000171000120000000	        D[AR] MASK[10.] DEST[Q] NORM $
20m0002                               	                ;Q=-Y
20m0002                               	        D[CONST 1] ROT[9.] ALU[D&Q]
20m0002 11266 510140014635022010000000	                COND[OBUS=0] JUMP[VIDVC2] C550 $
20m0002                               	                ;IF SIGN=1
20m0002 11267 640710014531020010000000	        D[CONST 1] ROT[8.] ALU[D-1] DEST[AR] NORM $
20m0002                               	                ;AR=377
20m0002 11270 640700000175024440000000	        D[AR] ROT[10.] ALU[DORQ] DEST[Q] NORM $
20m0002                               	                ;Q=0,,776 Y
20m0002 11271 640700600555000443000000	VIDVC2: ALU[Q] DEST[YMAX,,YMIN] DEST-A-MEM NORM $
20m0002                               	                ;YMAX,,YMIN=0,,Y
20m0002                               	
20m0002                               	;Get default color (0=no change).
20m0002                               	        D[10 + INTEN,,FRACT] ROT[25.] MASK[3] DEST[AR]
20m0002 11272 510150044571062030000000	                COND[OBUS=0] JUMP[VIDVC3] C550 $
20m0002                               	                ;AR=BRT (color)         if=0, no change
20m0002 11273 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11274 640720014435000600000000	        D[CONST 48.] ALU[D+Q] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+48.    read LAST COLOR,,LAST FONT
20m0002 11275 640700000171102440020000	        MAPF[NORM-RD] D[AR] ROT[33.] DEST[Q] NORM $
20m0002                               	                ;Q=COLOR 00000,,000000
20m0002 11276 640704204575000220000000	        D[MEM] MASK[18.] ALU[DORQ] DEST[MEMSTO] NORM $
20m0002                               	                ;HOLD=COLOR 00000,,LAST FONT    write LAST COLOR,,LAST FONT
20m0002                               	
20m0002                               	;Get default font (0=no change).
20m0002                               	VIDVC3: D[10 + INTEN,,FRACT] ROT[28.] MASK[3]
20m0002 11277 510140044571070030000000	                COND[OBUS=0] JUMP[VIDVC4] C550 $
20m0002                               	                ;if SIZE(FONT)=0, no change
20m0002 11300 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11301 640720014035000600000000	        D[CONST 48.] ALU[D+Q] DEST[Q MA] NORM $
20m0002                               	                ;Q,MA=POGB+48   read LAST COLOR,,LAST FONT
20m0002 11302 640700000571000440020000	        MAPF[NORM-RD] NORM $
20m0002                               	                ;WAIT
20m0002 11303 640710004571000000200000	        D[MEM] SPEC[LEFT] DEST[AR] NORM $
20m0002                               	                ;AR=COLOR,,0
20m0002 11304 640720044435070030000000	        D[10 + INTEN,,FRACT] ROT[28.] MASK[3] ALU[D+Q] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+48.+SIZE
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 181


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

20m0002 11305 640700000171000440020000	        MAPF[NORM-RD] D[AR] DEST[Q] NORM $
20m0002                               	                ;Q=COLOR,,0
20m0002 11306 640704404575000220000000	        D[MEM] MASK[18.] ALU[DORQ] DEST[HOLD] NORM $
20m0002                               	                ;HOLD=COLOR,,FONT
20m0002 11307 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11310 640724014435000600000000	        D[CONST 48.] ALU[D+Q] DEST[MA] STRT-WRT NORM $
20m0002                               	                ;Q,MA=POGB+48   write LAST COLOR,,LAST FONT
20m0002                               	
20m0002                               	;Check relative.
20m0002                               	VIDVC4: MAPF[NORM-RD] D[10 + INTEN,,FRACT] ROT[29.]
20m0002 11311 511140044571072440020000	                COND[OBUS<0] JUMP[VIDVC5] C550 $
20m0002                               	                ;if relative
20m0002                               	
20m0002                               	;If relative, add previous X coordinate.
20m0002 11312 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11313 640720014435000750000000	        D[CONST 61.] ALU[D+Q] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+61.    read X0,,X1
20m0002 11314 640700050171000440020000	        MAPF[NORM-RD] D[10 + XMAX,,XMIN] DEST[Q] NORM $
20m0002                               	                ;Q=0,,X
20m0002 11315 640710004435000220000000	        D[MEM] MASK[18.] ALU[D+Q] DEST[AR] NORM $
20m0002                               	                ;AR=0,,X+X1
20m0002 11316 640700004171044000200000	        D[MEM] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0002                               	                ;Q=X1,,0
20m0002 11317 640704200575000220000000	        D[AR] MASK[18.] ALU[DORQ] DEST[MEMSTO] NORM $
20m0002                               	                ;HOLD=X1,,X+X1  write X0,,X1
20m0002                               	
20m0002                               	;If relative, add previous Y coordinate.
20m0002 11320 640720024433000440000000	        D[MA] ALU[D+1] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+62.    read Y0,,Y1
20m0002 11321 640700054171000440020000	        MAPF[NORM-RD] D[10 + YMAX,,YMIN] DEST[Q] NORM $
20m0002                               	                ;Q=0,,Y
20m0002 11322 640710004435000220000000	        D[MEM] MASK[18.] ALU[D+Q] DEST[AR] NORM $
20m0002                               	                ;AR=0,,Y+Y1
20m0002 11323 640700004171044000200000	        D[MEM] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0002                               	                ;Q=Y1,,0
20m0002 11324 640144200575000220000000	        D[AR] MASK[18.] ALU[DORQ] DEST[MEMSTO] JUMP[VIDVC6] NORM $
20m0002                               	                ;HOLD=Y1,,Y+Y1  write Y0,,Y1
20m0002                               	
20m0002                               	;If absolute,just copy X
20m0002 11325 640700074171000220000000	VIDVC5: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11326 640720014435000750000000	        D[CONST 61.] ALU[D+Q] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+61.    read X0,,X1
20m0002 11327 640700050171000440020000	        MAPF[NORM-RD] D[10 + XMAX,,XMIN] DEST[Q] NORM $
20m0002                               	                ;Q=0,,X
20m0002 11330 640704204575044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[MEMSTO] NORM $
20m0002                               	                ;HOLD=X1,,X     write X0,,X1
20m0002                               	
20m0002                               	;If absolute, just copy Y
20m0002 11331 640720024433000440000000	        D[MA] ALU[D+1] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+62.    read Y0,,Y1
20m0002 11332 640700054171000440020000	        MAPF[NORM-RD] D[10 + YMAX,,YMIN] DEST[Q] NORM $
20m0002                               	                ;Q=0,,Y
20m0002 11333 640704204575044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[MEMSTO] NORM $
20m0002                               	                ;HOLD=Y1,,Y     write Y0,,Y1
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 182


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

20m0002                               	
20m0002                               	;Check type code. If 0, visible vector. (For now, all others invisible.)
20m0002                               	VIDVC6: D[10 + INTEN,,FRACT] ROT[32.] MASK[2]
20m0002 11334 530140044571100020000673	                COND[-OBUS=0] JUMP[VIDDON] C550 $
20m0002                               	                ;If T NEQ 0, done
20m0002                               	
20m0002                               	;Check first half done.
20m0002                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q]
20m0002 11335 656140074171000220000000	                COND[HALF] JUMP[VIDVCH] NORM $
20m0002                               	                ;Q=POGB         If -HALF
20m0002                               	
20m0002                               	;If first half not done, color=modified last color 77777,,777777
20m0002 11336 640720014435000600000000	        D[CONST 48.] ALU[Q+D] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+48.    read LAST COLOR
20m0002 11337 640710014531102010020000	        MAPF[NORM-RD] D[CONST 1] ROT[33.] ALU[D-1] DEST[AR] NORM $
20m0002                               	                ;AR=077777,,777777
20m0002 11340 640700004171000440000000	        D[MEM] DEST[Q] NORM $
20m0002                               	                ;Q=LAST COLOR,,LAST FONT
20m0002                               	        D[MEM] ROT[2] MASK[2]
20m0002 11341 510140004571004020000000	                COND[OBUS=0] JUMP[VIDVIM] C550 $
20m0002                               	                ;If color>1
20m0002 11342 640700014175102070000000	        D[CONST 7] ROT[33.] ALU[DORQ] DEST[Q] NORM $
20m0002                               	                ;Q=COLOR 7 (WHITE FROM COLOR)
20m0002                               	VIDVIM:
20m0002                               	.REPEAT VIC2 [
20m0002                               	        D[AR] ALU[DORQ] DEST[IOD] START-OUT NORM $
20m0002                               	                ;IOD=MODIFIED LAST COLOR 77777,,777777
20m0002                               	];VIC2
20m0002                               	.REPEAT 1 - VIC2 [
20m0002                               	        D[AR] ALU[DORQ] DEST[HOLD] NORM $
20m0002                               	                ;MEM=MODIFIED LAST COLOR 77777,,777777
20m0002                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002                               	        D[CONST 59.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
20m0002                               	                ;MA=POGB+59     write <COLOR MASK,,MASK>
20m0002                               	        MAPF[NORM-RD] JUMP[VIDVI0] NORM $
20m0002                               	                ;WAIT
20m0002                               	];[
20m0002 11343 640704400575000440000000	        D[AR] ALU[DORQ] DEST[HOLD] NORM $
20m0002                               	                ;MEM=MODIFIED LAST COLOR 77777,,777777
20m0002 11344 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11345 640724014435000730000000	        D[CONST 59.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
20m0002                               	                ;MA=POGB+59     write <COLOR MASK,,MASK>
20m0002 11346 640140000571000440020000	        MAPF[NORM-RD] JUMP[VIDVI0] NORM $
20m0002                               	                ;WAIT
20m0002                               	]1-VIC2
20m0002                               	
20m0002                               	;If first half done, color=default color 00000,,000000
20m0002 11347 640720014435000600000000	VIDVCH: D[CONST 48.] ALU[Q+D] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+48.    read LAST COLOR
20m0002 11350 640710014531102010020000	        MAPF[NORM-RD] D[CONST 1] ROT[33.] ALU[D-1] DEST[AR] NORM $
20m0002                               	                ;AR=077777,,777777
20m0002 11351 640700004171000440000000	        D[MEM] DEST[Q] NORM $
20m0002                               	                ;Q=LAST COLOR,,LAST FONT
20m0002                               	.REPEAT VIC2 [
20m0002                               	        D[AR] ALU[-D&Q] DEST[IOD] START-OUT NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 183


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

20m0002                               	                ;IOD=LAST COLOR 00000,,000000
20m0002                               	];VIC2
20m0002                               	.REPEAT 1 - VIC2 [
20m0002                               	        D[AR] ALU[-D&Q] DEST[HOLD] NORM $
20m0002                               	                ;MEM=LAST COLOR 00000,,000000
20m0002                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002                               	        D[CONST 59.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
20m0002                               	                ;MA=POGB+59     write <COLOR MASK,,MASK>
20m0002                               	        MAPF[NORM-RD] NORM $
20m0002                               	                ;WAIT
20m0002                               	];[
20m0002 11352 640704400675000440000000	        D[AR] ALU[-D&Q] DEST[HOLD] NORM $
20m0002                               	                ;MEM=LAST COLOR 00000,,000000
20m0002 11353 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11354 640724014435000730000000	        D[CONST 59.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
20m0002                               	                ;MA=POGB+59     write <COLOR MASK,,MASK>
20m0002 11355 640700000571000440020000	        MAPF[NORM-RD] NORM $
20m0002                               	                ;WAIT
20m0002                               	]1-VIC2
20m0002                               	
20m0002                               	;Save X0,,X1 and form XMAX,,XMIN.
20m0002 11356 240700074171000440100000	VIDVI0: MAPF[10] D[10 + POG,,POGB] DEST[Q] C800 $
20m0002                               	                ;VLDCOL         Q=POGB
20m0002 11357 640720014435000750000000	        D[CONST 61.] ALU[D+Q] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+61.    read X0,,X1
20m0002 11360 640700000571000440020000	        MAPF[NORM-RD] NORM $
20m0002                               	                ;WAIT FOR MEM
20m0002 11361 640700404171000443000000	        D[MEM] DEST[Q XMAX,,XMIN] DEST-A-MEM NORM $
20m0002                               	                ;Q,XMAX,,XMIN=X0,,X1
20m0002 11362 640701004571000443000000	        D[MEM] DEST[DXDY,,FRACT] DEST-A-MEM NORM $
20m0002                               	                ;DXDY,,FRACT=X0,,X1     (for use below)
20m0002                               	        D[MEM] ROT[18.] ALU[Q-D]
20m0002 11363 471140004477044440000000	                COND[-OBUS<0] JUMP[VIDVI1] C600 $
20m0002                               	                ;If X0,,X1-X1,,X0<0
20m0002 11364 640700404571044443000000	        D[MEM] ROT[18.] DEST[XMAX,,XMIN] DEST-A-MEM NORM $
20m0002                               	                ;XMAX,,XMIN=X1,,X0
20m0002                               	
20m0002                               	;Save Y0,,Y1 and form YMAX,,YMIN.
20m0002 11365 640700074171000440000000	VIDVI1: D[10 + POG,,POGB] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11366 640720014435000760000000	        D[CONST 62.] ALU[D+Q] DEST[MA] NORM $
20m0002                               	                ;MA=POGB+62.    read Y0,,Y1
20m0002 11367 640700000571000440020000	        MAPF[NORM-RD] NORM $
20m0002                               	                ;WAIT FOR MEM
20m0002 11370 640700604171000443000000	        D[MEM] DEST[Q YMAX,,YMIN] DEST-A-MEM NORM $
20m0002                               	                ;Q,YMAX,,YMIN=Y0,,Y1
20m0002 11371 640701204571000443000000	        D[MEM] DEST[A3DYDX,,FRACT] DEST-A-MEM NORM $
20m0002                               	                ;A3DYDX,,FRACT=Y0,,Y1   (for use below)
20m0002                               	        D[MEM] ROT[18.] ALU[Q-D]
20m0002 11372 471140004477044440000000	                COND[-OBUS<0] JUMP[VIDVI2] C600 $
20m0002                               	                ;If Y0,,Y1-Y1,,Y0<0
20m0002 11373 640700604571044443000000	        D[MEM] ROT[18.] DEST[YMAX,,YMIN] DEST-A-MEM NORM $
20m0002                               	                ;YMAX,,YMIN=Y1,,Y0
20m0002                               	
20m0002                               	;Form delta X. Check for vertical vectors.
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 184


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

20m0002 11374 640700060171044000200000	VIDVI2: D[10 + DXDY,,FRACT] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0002                               	                ;Q=X1,,0
20m0002 11375 640700060077000000200000	        D[10 + DXDY,,FRACT] SPEC[LEFT] ALU[Q-D] DEST[Q] NORM $
20m0002                               	                ;Q=DX,,0=X1,,0-X0,,0
20m0002                               	        ALU[Q] DEST[DXDY,,FRACT] DEST-A-MEM
20m0002 11376 510141000555000443000000	                COND[OBUS=0] JUMP[VIDVRV] C550 $
20m0002                               	                ;DXDY,,FRACT=DX,,0 (for use below)
20m0002                               	                ;If DX=0, vertical vector
20m0002                               	
20m0002                               	;Form delta Y. Check for horizontal vectors.
20m0002 11377 640700064171044000200000	        D[10 + A3DYDX,,FRACT] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0002                               	                ;Q=Y1,,0
20m0002 11400 640700064077000000200000	        D[10 + A3DYDX,,FRACT] SPEC[LEFT] ALU[Q-D] DEST[Q] NORM $
20m0002                               	                ;Q=DY,,0=Y1,,0-Y0,,0
20m0002                               	        ALU[Q] DEST[A3DYDX,,FRACT] DEST-A-MEM
20m0002 11401 510141200555000443000000	                COND[OBUS=0] JUMP[VIDHZV] C550 $
20m0002                               	                ;A3DYDX,,FRACT=DY,,0 (for use below)
20m0002                               	                ;If DY=0, horizontal vector
20m0002                               	
20m0002                               	;Form DXDY and A3DYDX.
20m0002 11402 640710060571000440000000	        D[10 + DXDY,,FRACT] DEST[AR] NORM $
20m0002                               	                ;AR=DIVIDEND=DX,,0
20m0002 11403 640044464571000440000000	        D[10 + A3DYDX,,FRACT] DEST[HOLD] PUSHJ[VIDDIV] NORM $
20m0002                               	                ;HOLD=DIVISOR=DY,,0     divide
20m0002 11404 640710000555000440000000	        ALU[Q] DEST[AR] NORM $
20m0002                               	                ;AR=DX/DY,,FRACT (abs val)
20m0002 11405 640700060171000440000000	        D[10 + DXDY,,FRACT] DEST[Q] NORM $
20m0002                               	                ;Q=DX
20m0002                               	        D[10 + A3DYDX,,FRACT] ALU[D#Q]
20m0002 11406 531140064735000440000000	                COND[-OBUS<0] JUMP[VIDVI3] C550 $
20m0002                               	                ;IF DX XOR DY < 0
20m0002 11407 640710000473000440000000	        D[AR] ALU[0-D] DEST[AR] NORM $
20m0002                               	                ;AR=-DX/DY (correct sign)
20m0002 11410 640704460571000440000000	VIDVI3: D[10 + DXDY,,FRACT] DEST[HOLD] NORM $
20m0002                               	                ;HOLD=DIVISOR=DX
20m0002 11411 640701000571000443000000	        D[AR] DEST[DXDY,,FRACT] DEST-A-MEM NORM $
20m0002                               	                ;DXDY,,FRACT=DX/DY,,FRACT
20m0002 11412 640050064571000440000000	        D[10 + A3DYDX,,FRACT] DEST[AR] PUSHJ[VIDDIV] NORM $
20m0002                               	                ;AR=DIVIDEND=DY         divide
20m0002 11413 640710000555000440000000	        ALU[Q] DEST[AR] NORM $
20m0002                               	                ;AR=DY/DX,,FRACT        (abs val)
20m0002 11414 640701200435002443000000	        D[AR] ROT[1] ALU[Q+D] DEST[A3DYDX,,FRACT] DEST-A-MEM NORM $
20m0002                               	                ;A3DYDX=3*ABS[DY/DX]
20m0002                               	
20m0002                               	;Initialize OFFSET,,LINE.
20m0002 11415 640700054171000220000000	        D[10 + YMAX,,YMIN] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=0,,YMIN
20m0002 11416 640701400555000443000000	        ALU[Q] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0002                               	                ;OFFSET,,LINE=0,,YMIN
20m0002                               	
20m0002                               	;Initialize PIXEL,,FRACT and form boundary limits from POG windows.
20m0002 11417 640700050171044000200000	        D[10 + XMAX,,XMIN] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0002                               	                ;Q=XMIN,,0
20m0002                               	        D[10 + DXDY,,FRACT]
20m0002 11420 531140060571000440000000	                COND[-OBUS<0] JUMP[VIDVI4] C550 $
20m0002                               	                ;If slope negative
20m0002 11421 640700050171000000200000	        D[10 + XMAX,,XMIN] SPEC[LEFT] DEST[Q] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 185


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

20m0002                               	                ;Q=XMAX,,0
20m0002 11422 640040000555000443000000	VIDVI4: ALU[Q] DEST[PIXEL,,FRACT] DEST-A-MEM PUSHJ[VIDVLM] NORM $
20m0002                               	                ;PIXEL,,FRACT=Q         form boundary limits
20m0002                               	
20m0002                               	;Check to see what side of 45 degrees vector's slope is.
20m0002 11423 640700064171000440000000	        D[10 + A3DYDX,,FRACT] DEST[Q] NORM $
20m0002                               	                ;Q=A3DYDX,,FRACT
20m0002                               	        D[CONST 3] ROT[18.] ALU[Q-D]
20m0002 11424 451140014477044030000000	                COND[OBUS<0] JUMP[VIDLL2] C600 $
20m0002                               	                ;If A3DYDX,,FRACT-3,,0<0, other case
20m0002                               	
20m0002                               	;This is the loop for painting 1 line of vectors whose slope is between
20m0002                               	;45 degrees (inclusive) and vertical (exclusive).
20m0002                               	
20m0002                               	;Check for above window.
20m0002 11425 640700054171044000200000	VIDLL1: D[10 + YMAX,,YMIN] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0002                               	                ;Q=YMIN,,0
20m0002                               	        D[10 + OFFSET,,LINE] ROT[18.] SPEC[LEFT] ALU[D-Q]
20m0002 11426 451140070537044000200000	                COND[OBUS<0] JUMP[VIDSL1] C600 $
20m0002                               	                ;If LINE,,0-YMIN,,0<0, skip line
20m0002                               	;Paint left.
20m0002 11427 640700040171000220000000	        D[10 + PIXEL,,FRACT] MASK[18.] ALU[D] DEST[Q] NORM $
20m0002                               	                ;Q=0,,FRACT(PIXEL)
20m0002 11430 640710014137044010000000	        D[CONST 1] ROT[18.] ALU[D-Q] DEST[Q AR] NORM $
20m0002                               	                ;Q,AR=1,,0-0,,FRACT(PIXEL)
20m0002 11431 640700200435002443000000	        D[AR] ROT[1] ALU[D+Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
20m0002                               	                ;INTEN,,FRACT=3*(1,,0-0,,FRACT(PIXEL))
20m0002                               	
20m0002                               	        VIDLFT
20m0002                               	
20m0002 11432 640700070171000220000000	[       D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=0,,LINE
20m0002 11433 640701400555000443000000	        ALU[Q] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0002                               	                ;OFFSET,,LINE=0,,LINE
20m0002                               	
20m0002 11434 640040000571000440000000	        PUSHJ[VIDDT1] NORM $
20m0002                               	                ;Do it
20m0002                               	
20m0002 11435 240700044171000440070000	        MAPF[7] D[10 + INTEN,,FRACT] DEST[Q] C800 $
20m0002                               	                ;Q=INTEN,,FRACT         VWEVID
20m0002 11436 640700064077000440000000	        D[10 + A3DYDX,,FRACT] ALU[Q-D] DEST[Q] NORM $
20m0002                               	                ;Q=INTEN,,FRACT-A3DYDX,,FRACT
20m0002 11437 640700200555000443000000	        ALU[Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
20m0002                               	                ;AMEM[1]=INTEN,,FRACT-A3DYDX,,FRACT
20m0002                               	        D[CONST 4] ROT[15.] ALU[Q-D-1]
20m0002 11440 451140014475036040001451	                COND[OBUS<0] JUMP[. + 9] C600 $
20m0002                               	                ;If INTEN,,FRACT-0,,377777<0, done.
20m0002                               	
20m0002 11441 640700070171000440000000	        D[10 + OFFSET,,LINE] DEST[Q] NORM $
20m0002                               	                ;Q=OFFSET,,LINE
20m0002 11442 640701414477044013000000	        D[CONST 1] ROT[18.] ALU[Q-D] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0002                               	                ;OFFSET-1,,LINE
20m0002                               	
20m0002 11443 661140000571000440001434	        COND[-INTRPT] JUMP[. - 7] NORM $
20m0002                               	                ;Loop if no interrupt
20m0002       11434	        %VIDFOO = (. - 8)       ;NOTE: THIS FORCES EVALUATION BEFORE
20m0002                               	        VIDSAV[%VIDFOO] 
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 186


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

20m0002 11444 640700014171030010000000	[       D[CONST (%VIDFOO / 10000)] ROT[12.] DEST[Q] NORM $
20m0002                               	                ;Q=high bit (SDISP loads all 16 bits)
20m0002 11445 640700014175014140000000	        D[CONST (77 & (%VIDFOO / 100))] ROT[6] ALU[QORD] DEST[Q] NORM $
20m0002                               	                ;Q=next 6 ADR bits
20m0002 11446 640704414575000340000000	        D[CONST (%VIDFOO \ 100)] ALU[QORD] DEST[HOLD] NORM $
20m0002                               	                ;Q=SAVE ADR
20m0002 11447 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0002                               	                ;Q=POGB
20m0002 11450 640164014435000720000710	        D[CONST 58.] ALU[Q+D] DEST[MA] STRT-WRT JUMP[VIDINT] NORM $
20m0002                               	                ;MA=POGB+58     write SAVE ADR
20m0002                               	]       ;       THE MACRO GETS ITS ARGUMENT.
20m0002                               	                ;Interrupt
20m0003                               	]
20m0003                               	;Paint right.
20m0003 11451 640710040171000220000000	        D[10 + PIXEL,,FRACT] MASK[18.] DEST[Q AR] NORM $
20m0003                               	                ;Q=0,,FRACT(PIXEL)
20m0003 11452 640700200435002443000000	        D[AR] ROT[1] ALU[D+Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
20m0003                               	                ;INTEN,,FRACT=3*0,,FRACT(PIXEL)
20m0003                               	
20m0003                               	        VIDRGT
20m0003                               	
20m0003 11453 640700070171000220000000	[       D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
20m0003                               	                ;Q=0,,LINE
20m0003 11454 640701414575044013000000	        D[CONST 1] ROT[18.] ALU[QORD] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0003                               	                ;OFFSET,,LINE=1,,LINE
20m0003                               	
20m0003 11455 640040000571000440000000	        PUSHJ[VIDDT1] NORM $
20m0003                               	                ;Do it (loop to here)
20m0003                               	
20m0003 11456 240700044171000440070000	        MAPF[7] D[10 + INTEN,,FRACT] DEST[Q] C800 $
20m0003                               	                ;Q=INTEN,,FRACT         VWEVID
20m0003 11457 640700064077000440000000	        D[10 + A3DYDX,,FRACT] ALU[Q-D] DEST[Q] NORM $
20m0003                               	                ;Q=INTEN,,FRACT-A3DYDX,,FRACT
20m0003 11460 640700200555000443000000	        ALU[Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
20m0003                               	                ;AMEM[1]=INTEN,,FRACT-A3DYDX,,FRACT
20m0003                               	        D[CONST 4] ROT[15.] ALU[Q-D-1]
20m0003 11461 451140014475036040001472	                COND[OBUS<0] JUMP[. + 9] C600 $
20m0003                               	                ;If INTEN,,FRACT-0,,377777<0, done.
20m0003                               	
20m0003 11462 640700070171000440000000	        D[10 + OFFSET,,LINE] DEST[Q] NORM $
20m0003                               	                ;Q=OFFSET,,LINE
20m0003 11463 640701414435044013000000	        D[CONST 1] ROT[18.] ALU[Q+D] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0003                               	                ;OFFSET+1,,LINE
20m0003                               	
20m0003 11464 661140000571000440001455	        COND[-INTRPT] JUMP[. - 7] NORM $
20m0003                               	                ;Loop if no interrupt
20m0003       11455	        %VIDFOO = (. - 8)       ;NOTE: THIS FORCES EVALUATION BEFORE
20m0003                               	        VIDSAV[%VIDFOO] 
20m0003 11465 640700014171030010000000	[       D[CONST (%VIDFOO / 10000)] ROT[12.] DEST[Q] NORM $
20m0003                               	                ;Q=high bit (SDISP loads all 16 bits)
20m0003 11466 640700014175014140000000	        D[CONST (77 & (%VIDFOO / 100))] ROT[6] ALU[QORD] DEST[Q] NORM $
20m0003                               	                ;Q=next 6 ADR bits
20m0003 11467 640704414575000550000000	        D[CONST (%VIDFOO \ 100)] ALU[QORD] DEST[HOLD] NORM $
20m0003                               	                ;Q=SAVE ADR
20m0003 11470 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0003                               	                ;Q=POGB
20m0003 11471 640164014435000720000710	        D[CONST 58.] ALU[Q+D] DEST[MA] STRT-WRT JUMP[VIDINT] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 187


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

20m0003                               	                ;MA=POGB+58     write SAVE ADR
20m0003                               	]       ;       THE MACRO GETS ITS ARGUMENT.
20m0003                               	                ;Interrupt
20m0004                               	]
20m0004                               	;Reset offset and increment line.
20m0004 11472 640700070171000220000000	VIDSL1: D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
20m0004                               	                ;Q=0,,LINE
20m0004 11473 640701400417000443000000	        ALU[Q+1] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0004                               	                ;OFFSET,,LINE=0,,LINE+1
20m0004                               	
20m0004                               	;Check for below window.
20m0004 11474 640700070171044000200000	        D[10 + OFFSET,,LINE] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0004                               	                ;Q=LINE,,0
20m0004                               	        D[10 + YMAX,,YMIN] SPEC[LEFT] ALU[D-Q]
20m0004 11475 451140054537000000200000	                COND[OBUS<0] JUMP[VIDVEN] C600 $
20m0004                               	                ;If YMAX,,0-LINE,,0<0, terminate
20m0004                               	
20m0004                               	;Increment X position.
20m0004 11476 640700040171000440000000	        D[10 + PIXEL,,FRACT] DEST[Q] NORM $
20m0004                               	                ;Q=PIXEL,,FRACT
20m0004 11477 640700060035000440000000	        D[10 + DXDY,,FRACT] ALU[Q+D] DEST[Q] NORM $
20m0004                               	                ;Q=PIXEL,,FRACT+DXDY,,FRACT
20m0004 11500 640140000555000443001425	        ALU[Q] DEST[PIXEL,,FRACT] DEST-A-MEM JUMP[VIDLL1] NORM $
20m0004                               	                ;PIXEL,,FRACT=PIXEL,,FRACT+DXDY,,FRACT  loop
20m0004                               	
20m0004                               	;This is the loop for vectors whose slope is between 45 degrees (exclusive)
20m0004                               	;and horizontal (exclusive).
20m0004                               	
20m0004                               	;Check for above window.
20m0004 11501 640700054171044000200000	VIDLL2: D[10 + YMAX,,YMIN] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0004                               	                ;Q=YMIN,,0
20m0004                               	        D[10 + OFFSET,,LINE] ROT[18.] SPEC[LEFT] ALU[D-Q]
20m0004 11502 451140070537044000200000	                COND[OBUS<0] JUMP[VIDSL2] C600 $
20m0004                               	                ;If LINE,,0-YMIN,,0<0, skip line
20m0004                               	
20m0004                               	;Paint left.
20m0004                               	        D[10 + PIXEL,,FRACT] ROT[36. - 2] MASK[16.] DEST[Q]
20m0004 11503 640040040171104200000000	                PUSHJ[VIDMUL] NORM $
20m0004                               	                ;Q=MULTIPLIER(0,,00 16 BIT)     multiply
20m0004 11504 640700214537044033000000	        D[CONST 3] ROT[18.] ALU[D-Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
20m0004                               	                ;INTEN,,FRACT=3,,0-0,,DELTA*A3DYDX,,FRACT
20m0004                               	
20m0004                               	        VIDLFT
20m0004                               	
20m0004 11505 640700070171000220000000	[       D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
20m0004                               	                ;Q=0,,LINE
20m0004 11506 640701400555000443000000	        ALU[Q] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0004                               	                ;OFFSET,,LINE=0,,LINE
20m0004                               	
20m0004 11507 640040000571000440000000	        PUSHJ[VIDDT1] NORM $
20m0004                               	                ;Do it
20m0004                               	
20m0004 11510 240700044171000440070000	        MAPF[7] D[10 + INTEN,,FRACT] DEST[Q] C800 $
20m0004                               	                ;Q=INTEN,,FRACT         VWEVID
20m0004 11511 640700064077000440000000	        D[10 + A3DYDX,,FRACT] ALU[Q-D] DEST[Q] NORM $
20m0004                               	                ;Q=INTEN,,FRACT-A3DYDX,,FRACT
20m0004 11512 640700200555000443000000	        ALU[Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 188


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

20m0004                               	                ;AMEM[1]=INTEN,,FRACT-A3DYDX,,FRACT
20m0004                               	        D[CONST 4] ROT[15.] ALU[Q-D-1]
20m0004 11513 451140014475036040001524	                COND[OBUS<0] JUMP[. + 9] C600 $
20m0004                               	                ;If INTEN,,FRACT-0,,377777<0, done.
20m0004                               	
20m0004 11514 640700070171000440000000	        D[10 + OFFSET,,LINE] DEST[Q] NORM $
20m0004                               	                ;Q=OFFSET,,LINE
20m0004 11515 640701414477044013000000	        D[CONST 1] ROT[18.] ALU[Q-D] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0004                               	                ;OFFSET-1,,LINE
20m0004                               	
20m0004 11516 661140000571000440001507	        COND[-INTRPT] JUMP[. - 7] NORM $
20m0004                               	                ;Loop if no interrupt
20m0004       11507	        %VIDFOO = (. - 8)       ;NOTE: THIS FORCES EVALUATION BEFORE
20m0004                               	        VIDSAV[%VIDFOO] 
20m0004 11517 640700014171030010000000	[       D[CONST (%VIDFOO / 10000)] ROT[12.] DEST[Q] NORM $
20m0004                               	                ;Q=high bit (SDISP loads all 16 bits)
20m0004 11520 640700014175014150000000	        D[CONST (77 & (%VIDFOO / 100))] ROT[6] ALU[QORD] DEST[Q] NORM $
20m0004                               	                ;Q=next 6 ADR bits
20m0004 11521 640704414575000070000000	        D[CONST (%VIDFOO \ 100)] ALU[QORD] DEST[HOLD] NORM $
20m0004                               	                ;Q=SAVE ADR
20m0004 11522 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0004                               	                ;Q=POGB
20m0004 11523 640164014435000720000710	        D[CONST 58.] ALU[Q+D] DEST[MA] STRT-WRT JUMP[VIDINT] NORM $
20m0004                               	                ;MA=POGB+58     write SAVE ADR
20m0004                               	]       ;       THE MACRO GETS ITS ARGUMENT.
20m0004                               	                ;Interrupt
20m0005                               	]
20m0005                               	;Paint right.
20m0005 11524 640700040171104200000000	        D[10 + PIXEL,,FRACT] ROT[36. - 2] MASK[16.] DEST[Q] NORM $
20m0005                               	                ;Q=MULTIPLIER(0,,00 16 BIT)
20m0005 11525 640040014135040010000000	        D[CONST 1] ROT[16.] ALU[D-Q-1] DEST[Q] PUSHJ[VIDMUL] NORM $
20m0005                               	                ;Q=1-MULTIPLIER (0,,177777-16 BIT)      multiply
20m0005 11526 640700214537044033000000	        D[CONST 3] ROT[18.] ALU[D-Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
20m0005                               	                ;INTEN,,FRACT=3,,0-0,,DELTA*A3DYDX,,FRACT
20m0005                               	
20m0005                               	        VIDRGT
20m0005                               	
20m0005 11527 640700070171000220000000	[       D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
20m0005                               	                ;Q=0,,LINE
20m0005 11530 640701414575044013000000	        D[CONST 1] ROT[18.] ALU[QORD] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0005                               	                ;OFFSET,,LINE=1,,LINE
20m0005                               	
20m0005 11531 640040000571000440000000	        PUSHJ[VIDDT1] NORM $
20m0005                               	                ;Do it (loop to here)
20m0005                               	
20m0005 11532 240700044171000440070000	        MAPF[7] D[10 + INTEN,,FRACT] DEST[Q] C800 $
20m0005                               	                ;Q=INTEN,,FRACT         VWEVID
20m0005 11533 640700064077000440000000	        D[10 + A3DYDX,,FRACT] ALU[Q-D] DEST[Q] NORM $
20m0005                               	                ;Q=INTEN,,FRACT-A3DYDX,,FRACT
20m0005 11534 640700200555000443000000	        ALU[Q] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
20m0005                               	                ;AMEM[1]=INTEN,,FRACT-A3DYDX,,FRACT
20m0005                               	        D[CONST 4] ROT[15.] ALU[Q-D-1]
20m0005 11535 451140014475036040001546	                COND[OBUS<0] JUMP[. + 9] C600 $
20m0005                               	                ;If INTEN,,FRACT-0,,377777<0, done.
20m0005                               	
20m0005 11536 640700070171000440000000	        D[10 + OFFSET,,LINE] DEST[Q] NORM $
20m0005                               	                ;Q=OFFSET,,LINE
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 189


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

20m0005 11537 640701414435044013000000	        D[CONST 1] ROT[18.] ALU[Q+D] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0005                               	                ;OFFSET+1,,LINE
20m0005                               	
20m0005 11540 661140000571000440001531	        COND[-INTRPT] JUMP[. - 7] NORM $
20m0005                               	                ;Loop if no interrupt
20m0005       11531	        %VIDFOO = (. - 8)       ;NOTE: THIS FORCES EVALUATION BEFORE
20m0005                               	        VIDSAV[%VIDFOO] 
20m0005 11541 640700014171030010000000	[       D[CONST (%VIDFOO / 10000)] ROT[12.] DEST[Q] NORM $
20m0005                               	                ;Q=high bit (SDISP loads all 16 bits)
20m0005 11542 640700014175014150000000	        D[CONST (77 & (%VIDFOO / 100))] ROT[6] ALU[QORD] DEST[Q] NORM $
20m0005                               	                ;Q=next 6 ADR bits
20m0005 11543 640704414575000310000000	        D[CONST (%VIDFOO \ 100)] ALU[QORD] DEST[HOLD] NORM $
20m0005                               	                ;Q=SAVE ADR
20m0005 11544 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
20m0005                               	                ;Q=POGB
20m0005 11545 640164014435000720000710	        D[CONST 58.] ALU[Q+D] DEST[MA] STRT-WRT JUMP[VIDINT] NORM $
20m0005                               	                ;MA=POGB+58     write SAVE ADR
20m0005                               	]       ;       THE MACRO GETS ITS ARGUMENT.
20m0005                               	                ;Interrupt
20m0006                               	]
20m0006                               	;Increment line and reset offset.
20m0006 11546 640700070171000220000000	VIDSL2: D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
20m0006                               	                ;Q=0,,LINE
20m0006 11547 640701400417000443000000	        ALU[Q+1] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
20m0006                               	                ;OFFSET,,LINE=0,,LINE+1
20m0006                               	
20m0006                               	;Check for below window.
20m0006 11550 640700070171044000200000	        D[10 + OFFSET,,LINE] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
20m0006                               	                ;Q=LINE,,0
20m0006                               	        D[10 + YMAX,,YMIN] SPEC[LEFT] ALU[D-Q]
20m0006 11551 451140054537000000200000	                COND[OBUS<0] JUMP[VIDVEN] C600 $
20m0006                               	                ;If YMAX,,0-LINE,,0<0, terminate
20m0006                               	
20m0006                               	;Increment X position.
20m0006 11552 640700040171000440000000	        D[10 + PIXEL,,FRACT] DEST[Q] NORM $
20m0006                               	                ;Q=PIXEL,,FRACT
20m0006 11553 640700060035000440000000	        D[10 + DXDY,,FRACT] ALU[Q+D] DEST[Q] NORM $
20m0006                               	                ;Q=PIXEL,,FRACT+DXDY,,FRACT
20m0006 11554 640140000555000443001501	        ALU[Q] DEST[PIXEL,,FRACT] DEST-A-MEM JUMP[VIDLL2] NORM $
20m0006                               	                ;PIXEL,,FRACT=PIXEL,,FRACT+DXDY,,FRACT  loop
20m0006                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 190


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

21m0006                               	;Vertical Vectors
21m0006 11555 640040000571000440000000	VIDVRV: PUSHJ[VIDVLM] NORM $
21m0006                               	                ;Form boundary limits
21m0006                               	
21m0006 11556 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
21m0006                               	                ;Q=POGB
21m0006 11557 640720014435000750000000	        D[CONST 61.] ALU[D+Q] DEST[MA] NORM $
21m0006                               	                ;MA=POGB+61.    read X0,,X1
21m0006 11560 640710050171044000220000	        MAPF[NORM-RD] D[10 + XMAX,,XMIN] ROT[18.] SPEC[LEFT] DEST[Q AR] NORM $
21m0006                               	                ;Q,AR=XMIN,,0   (AR for use below)
21m0006                               	        D[MEM] SPEC[LEFT] ALU[D-Q]
21m0006 11561 451140004537000000200673	                COND[OBUS<0] JUMP[VIDDON] C600 $
21m0006                               	                ;If X0,,0-XMIN,,0<0, main loop
21m0006 11562 640700050171000000200000	        D[10 + XMAX,,XMIN] SPEC[LEFT] DEST[Q] NORM $
21m0006                               	                ;Q=XMAX,,0
21m0006                               	        D[MEM] SPEC[LEFT] ALU[Q-D]
21m0006 11563 451140004477000000200673	                COND[OBUS<0] JUMP[VIDDON] C600 $
21m0006                               	                ;If XMAX,,0-X0,,0<0, main loop
21m0006                               	
21m0006 11564 640700000571000443000000	        D[AR] DEST[PIXEL,,FRACT] DEST-A-MEM NORM $
21m0006                               	                ;PIXEL,,FRACT=XMIN,,0
21m0006 11565 640700054171000220000000	        D[10 + YMAX,,YMIN] MASK[18.] DEST[Q] NORM $
21m0006                               	                ;Q=0,,YMIN
21m0006 11566 640701400555000443000000	        ALU[Q] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
21m0006                               	                ;OFFSET,,LINE=0,,YMIN
21m0006 11567 640700214571044033000000	        D[CONST 3] ROT[18.] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
21m0006                               	                ;INTEN,,FRACT=3,,0
21m0006                               	
21m0006 11570 640700054171000000200000	VIDVRL: D[10 + YMAX,,YMIN] SPEC[LEFT] DEST[Q] NORM $
21m0006                               	                ;Q=YMAX,,0
21m0006                               	        D[10 + OFFSET,,LINE] ROT[18.] SPEC[LEFT] ALU[Q-D]
21m0006 11571 451140070477044000200000	                COND[OBUS<0] JUMP[VIDVEN] C600 $
21m0006                               	                ;If YMAX,,0-LINE,,0<0 terminate
21m0006                               	
21m0006 11572 640040000571000440000000	        PUSHJ[VIDDOT] NORM $
21m0006                               	                ;Do one pixel
21m0006                               	
21m0006 11573 240700070171000220070000	        MAPF[7] D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] C800 $
21m0006                               	                ;Q=0,,LINE      VWEVID
21m0006                               	        ALU[Q+1] DEST[OFFSET,,LINE] DEST-A-MEM
21m0006 11574 661141400417000443001570	                COND[-INTRPT] JUMP[VIDVRL] NORM $
21m0006                               	                ;OFFSET,,LINE=0,,LINE+1         loop if no interrupt
21m0006                               	        VIDSAV[VIDVRL]
21m0006                               	
21m0006 11575 640700014171030010000000	[       D[CONST (VIDVRL / 10000)] ROT[12.] DEST[Q] NORM $
21m0006                               	                ;Q=high bit (SDISP loads all 16 bits)
21m0006 11576 640700014175014150000000	        D[CONST (77 & (VIDVRL / 100))] ROT[6] ALU[QORD] DEST[Q] NORM $
21m0006                               	                ;Q=next 6 ADR bits
21m0006 11577 640704414575000700000000	        D[CONST (VIDVRL \ 100)] ALU[QORD] DEST[HOLD] NORM $
21m0006                               	                ;Q=SAVE ADR
21m0006 11600 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
21m0006                               	                ;Q=POGB
21m0006 11601 640164014435000720000710	        D[CONST 58.] ALU[Q+D] DEST[MA] STRT-WRT JUMP[VIDINT] NORM $
21m0006                               	                ;MA=POGB+58     write SAVE ADR
21m0007                               	]               ;Interrupt
21m0007                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 191


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

22m0007                               	;Horizontal Vectors
22m0007 11602 640040000571000440000000	VIDHZV: PUSHJ[VIDVLM] NORM $
22m0007                               	                ;Form boundary limits
22m0007                               	
22m0007 11603 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
22m0007                               	                ;Q=POGB
22m0007 11604 640720014435000760000000	        D[CONST 62.] ALU[D+Q] DEST[MA] NORM $
22m0007                               	                ;MA=POGB+62.    read Y0,,Y1
22m0007 11605 640710054171044000220000	        MAPF[NORM-RD] D[10 + YMAX,,YMIN] ROT[18.] SPEC[LEFT] DEST[Q AR] NORM $
22m0007                               	                ;Q,AR=YMIN,,0 (AR for use below)
22m0007                               	        D[MEM] SPEC[LEFT] ALU[D-Q]
22m0007 11606 451140004537000000200673	                COND[OBUS<0] JUMP[VIDDON] C600 $
22m0007                               	                ;IF Y0,,0-YMIN,,0<0, main loop
22m0007 11607 640700054171000000200000	        D[10 + YMAX,,YMIN] SPEC[LEFT] DEST[Q] NORM $
22m0007                               	                ;Q=YMAX,,0
22m0007                               	        D[MEM] SPEC[LEFT] ALU[Q-D]
22m0007 11610 451140004477000000200673	                COND[OBUS<0] JUMP[VIDDON] C600 $
22m0007                               	                ;IF YMAX,,0-Y0,,0<0, main loop
22m0007                               	
22m0007 11611 640701400571044443000000	        D[AR] ROT[18.] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
22m0007                               	                ;OFFSET,,LINE=0,,YMIN
22m0007 11612 640700050171044000200000	        D[10 + XMAX,,XMIN] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
22m0007                               	                ;Q=XMIN,,0
22m0007 11613 640700000555000443000000	        ALU[Q] DEST[PIXEL,,FRACT] DEST-A-MEM NORM $
22m0007                               	                ;PIXEL,,FRACT=XMIN,,0
22m0007 11614 640700214571044033000000	        D[CONST 3] ROT[18.] DEST[INTEN,,FRACT] DEST-A-MEM NORM $
22m0007                               	                ;INTEN,,FRACT=3,,0
22m0007                               	
22m0007 11615 640700050171000000200000	VIDHZL: D[10 + XMAX,,XMIN] SPEC[LEFT] DEST[Q] NORM $
22m0007                               	                ;Q=XMAX,,0
22m0007                               	        D[10 + PIXEL,,FRACT] SPEC[LEFT] ALU[Q-D]
22m0007 11616 451140040477000000200000	                COND[OBUS<0] JUMP[VIDVEN] C600 $
22m0007                               	                ;If XMAX,,0-PIXEL,,0<0, terminate
22m0007                               	
22m0007 11617 640040000571000440000000	        PUSHJ[VIDDOT] NORM $
22m0007                               	                ;Do one pixel
22m0007                               	
22m0007 11620 240700040171000440070000	        MAPF[7] D[10 + PIXEL,,FRACT] DEST[Q] C800 $
22m0007                               	                ;Q=PIXEL,,FRACT         VWEVID
22m0007                               	        D[CONST 1] ROT[18.] ALU[Q+D] DEST[PIXEL,,FRACT] DEST-A-MEM
22m0007 11621 661140014435044013001615	                COND[-INTRPT] JUMP[VIDHZL] NORM $
22m0007                               	                ;PIXEL,,FRACT=PIXEL+1,,FRACT    loop if no interrupt
22m0007                               	        VIDSAV[VIDHZL]
22m0007                               	
22m0007 11622 640700014171030010000000	[       D[CONST (VIDHZL / 10000)] ROT[12.] DEST[Q] NORM $
22m0007                               	                ;Q=high bit (SDISP loads all 16 bits)
22m0007 11623 640700014175014160000000	        D[CONST (77 & (VIDHZL / 100))] ROT[6] ALU[QORD] DEST[Q] NORM $
22m0007                               	                ;Q=next 6 ADR bits
22m0007 11624 640704414575000150000000	        D[CONST (VIDHZL \ 100)] ALU[QORD] DEST[HOLD] NORM $
22m0007                               	                ;Q=SAVE ADR
22m0007 11625 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
22m0007                               	                ;Q=POGB
22m0007 11626 640164014435000720000710	        D[CONST 58.] ALU[Q+D] DEST[MA] STRT-WRT JUMP[VIDINT] NORM $
22m0007                               	                ;MA=POGB+58     write SAVE ADR
22m0008                               	]               ;Interrupt
22m0008                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 192


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

23m0008                               	;Vector endpoint cleanup (subtract away first point if visible)
23m0008 11627 640700074171000220000000	VIDVEN: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
23m0008                               	                ;Q=POGB
23m0008 11630 640720014435000760000000	        D[CONST 62.] ALU[Q+D] DEST[MA] NORM $
23m0008                               	                ;MA=POGB+62.    read Y0,,Y1
23m0008 11631 640700054171044000220000	        MAPF[NORM-RD] D[10 + YMAX,,YMIN] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
23m0008                               	                ;Q=YMIN,,0
23m0008                               	        D[MEM] SPEC[LEFT] ALU[D-Q]
23m0008 11632 451140004537000000200673	                COND[OBUS<0] JUMP[VIDDON] C600 $
23m0008                               	                ;If Y0,,0-YMIN,,0<0, main loop
23m0008 11633 640700054171000000200000	        D[10 + YMAX,,YMIN] SPEC[LEFT] DEST[Q] NORM $
23m0008                               	                ;Q=YMAX,,0
23m0008                               	        D[MEM] SPEC[LEFT] ALU[Q-D]
23m0008 11634 451140004477000000200673	                COND[OBUS<0] JUMP[VIDDON] C600 $
23m0008                               	                ;If YMAX,,0-Y0,,0<0, main loop
23m0008 11635 640710004571000000200000	        D[MEM] SPEC[LEFT] DEST[AR] NORM $
23m0008                               	                ;AR=Y0,,0       (for use below)
23m0008                               	
23m0008 11636 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
23m0008                               	                ;Q=POGB
23m0008 11637 640720014435000750000000	        D[CONST 61.] ALU[Q+D] DEST[MA] NORM $
23m0008                               	                ;MA=POGB+62.    read X0,,X1
23m0008 11640 640700050171044000220000	        MAPF[NORM-RD] D[10 + XMAX,,XMIN] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
23m0008                               	                ;Q=XMIN,,0
23m0008                               	        D[MEM] SPEC[LEFT] ALU[D-Q]
23m0008 11641 451140004537000000200673	                COND[OBUS<0] JUMP[VIDDON] C600 $
23m0008                               	                ;If X0,,0-XMIN,,0<0, main loop
23m0008 11642 640700050171000000200000	        D[10 + XMAX,,XMIN] SPEC[LEFT] DEST[Q] NORM $
23m0008                               	                ;Q=XMAX,,0
23m0008                               	        D[MEM] SPEC[LEFT] ALU[Q-D]
23m0008 11643 451140004477000000200673	                COND[OBUS<0] JUMP[VIDDON] C600 $
23m0008                               	                ;If XMAX,,0-X0,,0<0, main loop
23m0008                               	
23m0008 11644 640700004171000000200000	        D[MEM] SPEC[LEFT] DEST[Q] NORM $
23m0008                               	                ;Q=X0,,0
23m0008 11645 640700000555000443000000	        ALU[Q] DEST[PIXEL,,FRACT] DEST-A-MEM NORM $
23m0008                               	                ;PIXEL,,FRACT=X0,,0
23m0008 11646 640701400571044223000000	        D[AR] ROT[18.] MASK[18.] DEST[OFFSET,,LINE] DEST-A-MEM NORM $
23m0008                               	                ;OFFSET,,LINE=0,,Y0
23m0008 11647 640040214571044053000000	        D[CONST 5] ROT[18.] DEST[INTEN,,FRACT] DEST-A-MEM PUSHJ[VIDDOT] NORM $
23m0008                               	                ;INTEN,,FRACT=5,,0      Do it
23m0008 11650 240140000571000440070673	        MAPF[7] JUMP[VIDDON] C800 $
23m0008                               	                ;VWEVID         main loop
23m0008                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 193


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

24m0008                               	;Output one pixel
24m0008 11651 640700070171000220000000	VIDDOT: D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=0,,LINE
24m0008 11652 640141400555000443000000	        ALU[Q] DEST[OFFSET,,LINE] DEST-A-MEM JUMP[VIDDT2] NORM $
24m0008                               	                ;OFFSET,,LINE=0,,LINE
24m0008                               	
24m0008                               	;Enter here for limit check  
24m0008 11653 640700040171000000200000	VIDDT1: D[10 + PIXEL,,FRACT] SPEC[LEFT] DEST[Q] NORM $
24m0008                               	                ;Q=PIXEL,,0
24m0008 11654 640710070035000000200000	        D[10 + OFFSET,,LINE] SPEC[LEFT] ALU[Q+D] DEST[Q AR] NORM $
24m0008                               	                ;AR,Q=PIXEL,,0+OFFSET,,0
24m0008                               	        D[10 + XMAX,,XMIN] ROT[18.] SPEC[LEFT] ALU[Q-D]
24m0008 11655 451300050477044000200000	                COND[OBUS<0] POPJ C600 $
24m0008                               	                ;IF PIXEL,,0-XMIN,,0<0, RETURN
24m0008                               	        D[10 + XMAX,,XMIN] SPEC[LEFT] ALU[D-Q]
24m0008 11656 451300050537000000200000	                COND[OBUS<0] POPJ C600 $
24m0008                               	                ;IF XMAX,,0-PIXEL,,0<0, RETURN
24m0008                               	.REPEAT VIC2 [
24m0008                               	VIDDT2: D[AR] ROT[18.] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=0,,PIXEL
24m0008                               	        D[10 + OFFSET,,LINE] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[Q] NORM $
24m0008                               	                ;Q=LINE,,PIXEL
24m0008                               	        D[10 + INTEN,,FRACT] ROT[18.] MASK[3] DEST[AR] NORM $
24m0008                               	                ;AR=0,,INTEN
24m0008                               	        D[AR] ROT[33.] ALU[QORD] DEST[IOD] START-OUT NORM $
24m0008                               	                ;IOD=INTEN,LINE,,PIXEL
24m0008                               	        MAPF[13] START-IN C800 $
24m0008                               	                ;VLDPIX
24m0008                               	        MAPF[2] START-IN C800 $
24m0008                               	                ;VSYADR
24m0008                               	        MAPF[1] START-IN POPJ C800 $
24m0008                               	                ;VSYDAT return (Note: Next instructon must have MAPF[7])
24m0008                               	];VIC2
24m0008                               	.REPEAT 1 - VIC2 [
24m0008                               	VIDDT2: D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=0,,LINE
24m0008                               	        D[CONST 4] ROT[6] ALU[Q+D] DEST[AR] NORM $
24m0008                               	                ;AR=0,,LINE+256.
24m0008                               	        D[AR] ROT[5] MASK[14.] DEST[Q] NORM $
24m0008                               	                ;Q=0 LINE 00000
24m0008                               	        D[CONST 1] ROT[5] ALU[-D&Q] DEST[Q] NORM $
24m0008                               	                ;Q=0 LINE/2 000000
24m0008                               	        D[AR] ROT[36. - 1]
24m0008                               	                COND[-OBUS<0] JUMP[VIDDT3] C550 $
24m0008                               	                ;IF LSB[LINE]=1
24m0008                               	        D[CONST 1] ROT[14.] ALU[QORD] DEST[Q] NORM $
24m0008                               	                ;Q=ODD[LINE] LINE/2 000000
24m0008                               	VIDDT3: ALU[Q] DEST[HOLD] NORM $
24m0008                               	                ;MEM=INTERLACED LINE 000000
24m0008                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=POGB
24m0008                               	        D[CONST 60.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
24m0008                               	                ;MA=POGB+60.    write INTERLACED LINE 000000 (temp)
24m0008                               	
24m0008                               	        MAPF[NORM-RD] D[CONST 5] ROT[6] ALU[D-1] DEST[Q] NORM $
24m0008                               	                ;Q=319.
24m0008                               	        D[10 + PIXEL,,FRACT] ROT[18.] MASK[18.] ALU[Q+D] DEST[Q] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 194


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

24m0008                               	                ;Q=0,,PIXEL+319.
24m0008                               	        D[10 + OFFSET,,LINE] ROT[18.] MASK[18.] ALU[Q+D] DEST[AR] NORM $
24m0008                               	                ;Q=0,,PIXEL+0,,OFFSET+319.
24m0008                               	        D[AR] MASK[18.] DEST[Q AR] NORM $
24m0008                               	                ;Q,AR=0,,PIXEL+OFFSET+319.
24m0008                               	        D[AR] ROT[1] ALU[D+Q] DEST[AR] PUSHJ[VIDD33] NORM $
24m0008                               	                ;AR=3*corrected PIXEL   divide by 33
24m0008                               	
24m0008                               	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[AR] NORM $
24m0008                               	                ;AR=QUOTIENT,,REMAINDER=WORD,,PIXEL
24m0008                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=POGB
24m0008                               	        D[CONST 60.] ALU[Q+D] DEST[MA] NORM $
24m0008                               	                ;MA=POGB+60     read INTERLACED LINE 000000
24m0008                               	        MAPF[NORM-RD] D[AR] ROT[18.] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=WORD
24m0008                               	        D[MEM] ALU[QORD] DEST[Q] NORM $
24m0008                               	                ;Q=INTERLACED LINE 000000 + WORD (=interlaced address)
24m0008                               	
24m0008                               	        D[CONST 7] ROT[6] ALU[Q+D] DEST[Q] NORM $
24m0008                               	                ;Q=ADR+7*64.
24m0008                               	        D[CONST 6] ALU[Q+D] DEST[IOD] START-OUT NORM $
24m0008                               	                ;IOD=ADR+7 lines, 6 words
24m0008                               	
24m0008                               	        MAPF[2] D[AR] MASK[18.] DEST[Q] C800 $
24m0008                               	                ;VLDADR         Q=REMAINDER
24m0008                               	        D[CONST 30.] ALU[D-Q] DEST[ROTR] NORM $
24m0008                               	                ;ROTR=30-REMAINDER
24m0008                               	        D[10 + INTEN,,FRACT] DEST[Q] NORM $
24m0008                               	                ;Q=INTEN,,FRACT
24m0008                               	        D[CONST 4] ROT[15.] ALU[Q+D] DEST[AR] NORM $
24m0008                               	                ;AR=INTEN,,FRACT+0,,400000
24m0008                               	        D[AR] ROT[18.] MASK[3] DEST[AR] NORM $
24m0008                               	                ;AR=0,,INTEN
24m0008                               	        D[AR] ROT[R] DEST[AR] NORM $
24m0008                               	                ;AR=DATA correctly shifted
24m0008                               	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=POGB
24m0008                               	        D[CONST 59.] ALU[Q+D] DEST[MA] NORM $
24m0008                               	                ;MA=POGB+59.    read COLOR MASK,,MASK
24m0008                               	        MAPF[NORM-RD] D[AR] DEST[Q] NORM $
24m0008                               	                ;Q=DATA
24m0008                               	        D[MEM] ROT[2] MASK[2]
24m0008                               	                COND[-OBUS=0] PUSHJ[VIDCOL] C550 $
24m0008                               	                ;If bit(s) 0 or 1 of color on, "color" the word
24m0008                               	        D[MEM] ALU[D#Q] DEST[IOD] START-OUT NORM $
24m0008                               	                ;IOD=DATA XOR COLOR
24m0008                               	        MAPF[1] START-IN POPJ C800 $
24m0008                               	                ;VLDDAT (next line must have MAPF[7] ... C800)
24m0008                               	];[
24m0008 11657 640700070171000220000000	VIDDT2: D[10 + OFFSET,,LINE] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=0,,LINE
24m0008 11660 640710014435014040000000	        D[CONST 4] ROT[6] ALU[Q+D] DEST[AR] NORM $
24m0008                               	                ;AR=0,,LINE+256.
24m0008 11661 640700000171012160000000	        D[AR] ROT[5] MASK[14.] DEST[Q] NORM $
24m0008                               	                ;Q=0 LINE 00000
24m0008 11662 640700014275012010000000	        D[CONST 1] ROT[5] ALU[-D&Q] DEST[Q] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 195


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

24m0008                               	                ;Q=0 LINE/2 000000
24m0008                               	        D[AR] ROT[36. - 1]
24m0008 11663 531140000571106440000000	                COND[-OBUS<0] JUMP[VIDDT3] C550 $
24m0008                               	                ;IF LSB[LINE]=1
24m0008 11664 640700014175034010000000	        D[CONST 1] ROT[14.] ALU[QORD] DEST[Q] NORM $
24m0008                               	                ;Q=ODD[LINE] LINE/2 000000
24m0008 11665 640704400555000440000000	VIDDT3: ALU[Q] DEST[HOLD] NORM $
24m0008                               	                ;MEM=INTERLACED LINE 000000
24m0008 11666 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=POGB
24m0008 11667 640724014435000740000000	        D[CONST 60.] ALU[Q+D] DEST[MA] STRT-WRT NORM $
24m0008                               	                ;MA=POGB+60.    write INTERLACED LINE 000000 (temp)
24m0008                               	
24m0008 11670 640700014131014050020000	        MAPF[NORM-RD] D[CONST 5] ROT[6] ALU[D-1] DEST[Q] NORM $
24m0008                               	                ;Q=319.
24m0008 11671 640700040035044220000000	        D[10 + PIXEL,,FRACT] ROT[18.] MASK[18.] ALU[Q+D] DEST[Q] NORM $
24m0008                               	                ;Q=0,,PIXEL+319.
24m0008 11672 640710070435044220000000	        D[10 + OFFSET,,LINE] ROT[18.] MASK[18.] ALU[Q+D] DEST[AR] NORM $
24m0008                               	                ;Q=0,,PIXEL+0,,OFFSET+319.
24m0008 11673 640710000171000220000000	        D[AR] MASK[18.] DEST[Q AR] NORM $
24m0008                               	                ;Q,AR=0,,PIXEL+OFFSET+319.
24m0008 11674 640050000435002440001226	        D[AR] ROT[1] ALU[D+Q] DEST[AR] PUSHJ[VIDD33] NORM $
24m0008                               	                ;AR=3*corrected PIXEL   divide by 33
24m0008                               	
24m0008 11675 640710004575044000200000	        D[MEM] ROT[18.] SPEC[LEFT] ALU[DORQ] DEST[AR] NORM $
24m0008                               	                ;AR=QUOTIENT,,REMAINDER=WORD,,PIXEL
24m0008 11676 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=POGB
24m0008 11677 640720014435000740000000	        D[CONST 60.] ALU[Q+D] DEST[MA] NORM $
24m0008                               	                ;MA=POGB+60     read INTERLACED LINE 000000
24m0008 11700 640700000171044220020000	        MAPF[NORM-RD] D[AR] ROT[18.] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=WORD
24m0008 11701 640700004175000440000000	        D[MEM] ALU[QORD] DEST[Q] NORM $
24m0008                               	                ;Q=INTERLACED LINE 000000 + WORD (=interlaced address)
24m0008                               	
24m0008 11702 640700014035014070000000	        D[CONST 7] ROT[6] ALU[Q+D] DEST[Q] NORM $
24m0008                               	                ;Q=ADR+7*64.
24m0008 11703 640702214435000063600000	        D[CONST 6] ALU[Q+D] DEST[IOD] START-OUT NORM $
24m0008                               	                ;IOD=ADR+7 lines, 6 words
24m0008                               	
24m0008 11704 240700000171000220020000	        MAPF[2] D[AR] MASK[18.] DEST[Q] C800 $
24m0008                               	                ;VLDADR         Q=REMAINDER
24m0008 11705 640701214537000360000000	        D[CONST 30.] ALU[D-Q] DEST[ROTR] NORM $
24m0008                               	                ;ROTR=30-REMAINDER
24m0008 11706 640700044171000440000000	        D[10 + INTEN,,FRACT] DEST[Q] NORM $
24m0008                               	                ;Q=INTEN,,FRACT
24m0008 11707 640710014435036040000000	        D[CONST 4] ROT[15.] ALU[Q+D] DEST[AR] NORM $
24m0008                               	                ;AR=INTEN,,FRACT+0,,400000
24m0008 11710 640710000571044030000000	        D[AR] ROT[18.] MASK[3] DEST[AR] NORM $
24m0008                               	                ;AR=0,,INTEN
24m0008 11711 640710000571200440000000	        D[AR] ROT[R] DEST[AR] NORM $
24m0008                               	                ;AR=DATA correctly shifted
24m0008 11712 640700074171000220000000	        D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
24m0008                               	                ;Q=POGB
24m0008 11713 640720014435000730000000	        D[CONST 59.] ALU[Q+D] DEST[MA] NORM $
24m0008                               	                ;MA=POGB+59.    read COLOR MASK,,MASK
24m0008 11714 640700000171000440020000	        MAPF[NORM-RD] D[AR] DEST[Q] NORM $
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 196


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

24m0008                               	                ;Q=DATA
24m0008                               	        D[MEM] ROT[2] MASK[2]
24m0008 11715 530040004571004020001247	                COND[-OBUS=0] PUSHJ[VIDCOL] C550 $
24m0008                               	                ;If bit(s) 0 or 1 of color on, "color" the word
24m0008 11716 640702204735000443600000	        D[MEM] ALU[D#Q] DEST[IOD] START-OUT NORM $
24m0008                               	                ;IOD=DATA XOR COLOR
24m0008 11717 240300000571000443410000	        MAPF[1] START-IN POPJ C800 $
24m0008                               	                ;VLDDAT (next line must have MAPF[7] ... C800)
24m0008                               	]1-VIC2
24m0008                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 197


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

25m0008                               	;Compute Limits
25m0008 11720 640700074171000220000000	VIDVLM: D[10 + POG,,POGB] MASK[18.] DEST[Q] NORM $
25m0008                               	                ;Q=POGB
25m0008 11721 640700074035044040000000	        D[10 + POG,,POGB] ROT[18.] MASK[4] ALU[Q+D] DEST[Q] NORM $
25m0008                               	                ;Q=POGB+POG
25m0008 11722 640720014435000200000000	        D[CONST 16.] ALU[Q+D] DEST[MA] NORM $
25m0008                               	                ;MA=POGB+16.+POG        read POG XMAX,,XMIN
25m0008                               	
25m0008 11723 640700050171044000220000	        MAPF[NORM-RD] D[10 + XMAX,,XMIN] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
25m0008                               	                ;Q=XMIN,,0
25m0008                               	        D[MEM] ROT[18.] SPEC[LEFT] ALU[Q-D]
25m0008 11724 471140004477044000200000	                COND[-OBUS<0] JUMP[VIDVL1] C600 $
25m0008                               	                ;If XMIN,,0-POGXMIN,,0<0
25m0008 11725 640700050171000000200000	        D[10 + XMAX,,XMIN] SPEC[LEFT] DEST[Q] NORM $
25m0008                               	                ;Q=XMAX,,0
25m0008 11726 640700404575000223000000	        D[MEM] MASK[18.] ALU[DORQ] DEST[XMAX,,XMIN] DEST-A-MEM NORM $
25m0008                               	                ;XMAX,,XMIN=XMAX,,POGXMIN
25m0008                               	
25m0008 11727 640700050171000000200000	VIDVL1: D[10 + XMAX,,XMIN] SPEC[LEFT] DEST[Q] NORM $
25m0008                               	                ;Q=XMAX,,0
25m0008                               	        D[MEM] SPEC[LEFT] ALU[D-Q]
25m0008 11730 471140004537000000200000	                COND[-OBUS<0] JUMP[VIDVL2] C600 $
25m0008                               	                ;If POGXMAX,,0-XMAX,,0<0
25m0008 11731 640700050171000220000000	        D[10 + XMAX,,XMIN] MASK[18.] DEST[Q] NORM $
25m0008                               	                ;Q=0,,XMIN
25m0008 11732 640700004175000000200000	        D[MEM] SPEC[LEFT] ALU[DORQ] DEST[Q] NORM $
25m0008                               	                ;Q=POGXMAX,,XMIN
25m0008 11733 640700400555000443000000	        ALU[Q] DEST[XMAX,,XMIN] DEST-A-MEM NORM $
25m0008                               	                ;XMAX,,XMIN=POGXMAX,,XMIN
25m0008                               	
25m0008 11734 640700024171000440000000	VIDVL2: D[MA] DEST[Q] NORM $
25m0008                               	                ;Q=MA
25m0008 11735 640720014435000200000000	        D[CONST 16.] ALU[Q+D] DEST[MA] NORM $
25m0008                               	                ;MA=MA+16.      read POG YMAX,,YMIN
25m0008                               	
25m0008 11736 640700054171044000220000	        MAPF[NORM-RD] D[10 + YMAX,,YMIN] ROT[18.] SPEC[LEFT] DEST[Q] NORM $
25m0008                               	                ;Q=YMIN,,0
25m0008                               	        D[MEM] ROT[18.] SPEC[LEFT] ALU[Q-D]
25m0008 11737 471140004477044000200000	                COND[-OBUS<0] JUMP[VIDVL3] C600 $
25m0008                               	                ;If YMIN,,0-POGYMIN,,0<0
25m0008 11740 640700054171000000200000	        D[10 + YMAX,,YMIN] SPEC[LEFT] DEST[Q] NORM $
25m0008                               	                ;Q=YMAX,,0
25m0008 11741 640700604575000223000000	        D[MEM] MASK[18.] ALU[DORQ] DEST[YMAX,,YMIN] DEST-A-MEM NORM $
25m0008                               	                ;YMAX,,YMIN=YMAX,,POGYMIN
25m0008                               	
25m0008 11742 640700054171000000200000	VIDVL3: D[10 + YMAX,,YMIN] SPEC[LEFT] DEST[Q] NORM $
25m0008                               	                ;Q=YMAX,,0
25m0008                               	        D[MEM] SPEC[LEFT] ALU[D-Q]
25m0008 11743 471300004537000000200000	                COND[-OBUS<0] POPJ C600 $
25m0008                               	                ;If POGYMAX,,0-YMAX,,0<0
25m0008 11744 640700054171000220000000	        D[10 + YMAX,,YMIN] MASK[18.] DEST[Q] NORM $
25m0008                               	                ;Q=0,,YMIN
25m0008 11745 640700004175000000200000	        D[MEM] SPEC[LEFT] ALU[DORQ] DEST[Q] NORM $
25m0008                               	                ;Q=POGYMAX,,YMIN
25m0008 11746 640300600555000443000000	        ALU[Q] DEST[YMAX,,YMIN] DEST-A-MEM POPJ NORM $
25m0008                               	                ;YMAX,,YMIN=POGYMAX,,YMIN
25m0008                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 198


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

26m0008                               	;Multiply
26m0008                               	;A3DYDX,,FRACT=MULTIPLICAND(2 BIT,,16 BIT 00)   positive only
26m0008                               	;Q=MULTIPLIER(0,,00 16 BIT)                     positive only
26m0008 11747 640710064571036440000000	VIDMUL: D[10 + A3DYDX,,FRACT] ROT[15.] DEST[AR] NORM $
26m0008                               	                ;AR=MULTIPLICAND(0 17 BIT,,1 BIT 00000000000000000)
26m0008 11750 640704401215000440000000	        ACSEL[AC] ALU[0] DEST[O_AC HOLD] NORM $
26m0008                               	                ;HOLD=AC for safe keeping       AC=0
26m0008                               	;AR=MULTIPLICAND(0 17 BIT,,1 BIT 00000000000000000)
26m0008                               	;Q=MULTIPLIER(0,,00 16 BIT)
26m0008                               	;MEM=AC storage
26m0008 11751 640740014571000170000000	        D[CONST 15.] LLOAD NORM $
26m0008                               	                ;Loop 16 times
26m0008 11752 640240002021000030001752	        D[AR] ACSEL[AC] ALU[MULAC+D] DEST[D4] MASK[3] LOOP[.] NORM $
26m0008                               	                ;Add AR to AC depending on the low order bit of Q.
26m0008                               	                ;Shift AC,,Q right. High order bit of AC=OVR XOR -IOB<0
26m0008                               	;AC=PRODUCT(0 17 BIT,,18 BIT)
26m0008 11753 640710005171000440000000	        D[MEM] ACSEL[AC] DEST[O_AC AR] NORM $
26m0008                               	                ;AC=AC storage, AR=PRODUCT(0 17 BIT,,18 BIT)
26m0008 11754 640300000171052240000000	        D[AR] ROT[36. - 15.] MASK[20.] DEST[Q] POPJ NORM $
26m0008                               	                ;Q=PRODUCT(2 BIT,,18 BIT)       return
26m0008                               	;Q=PRODUCT(2 BIT,,18 BIT)
26m0008                               	
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 199


SLOE   Jan ***, 1859 00:00:03  file DSK:VID.SLO  --  of -- f2x

27m0008                               	;Divide
27m0008                               	;AR=DIVIDEND,,0
27m0008                               	;MEM=DIVISOR,,0
27m0008 11755 531140000571000440000000	VIDDIV: D[AR]   COND[-OBUS<0] JUMP[VIDDV1] C550 $
27m0008                               	                ;If AR<0
27m0008 11756 640710000473000440000000	        D[AR] ALU[0-D] DEST[AR] NORM $
27m0008                               	                ;ABS[AR]
27m0008 11757 640710001171044440000000	VIDDV1: D[AR] ROT[18.] ACSEL[AC] DEST[O_AC AR] NORM $
27m0008                               	                ;AR LSH -18. <-> AC
27m0008 11760 640700000215000440000000	        ALU[0] DEST[Q] NORM $
27m0008                               	                ;Q=0
27m0008 11761 531140004571000440000000	        D[MEM]  COND[-OBUS<0] JUMP[VIDDV2] C550 $
27m0008                               	                ;If MEM<0
27m0008 11762 640144404473000440000000	        D[MEM] ALU[0-D] DEST[HOLD] JUMP[VIDDV2] NORM $
27m0008                               	                ;ABS[MEM]
27m0008                               	
27m0008                               	: (. + 3) - (. \ 4)
27m0008                               	                ;.QUAD-1
27m0008 11763 640740014571000440000000	VIDDV2: D[CONST 36.] LLOAD NORM $
27m0008                               	                ;Loop 37 times
27m0008                               	
27m0008                               	VIDDVL: D[MEM] ALU[DIVAC-D] ACSEL[AC] DEST[D6] MASK[3]
27m0008 11764 451640007043000030001764	                COND[OBUS<0] SLOOP[VIDDVL] C600 $
27m0008                               	                ;Loop here if remainder positive
27m0008 11765 640310001171000440000000	        D[AR] ACSEL[AC] ALU[D] DEST[O_AC AR] POPJ NORM $
27m0008                               	                ;Swap AR <-> AC and return
27m0008                               	        D[MEM] ALU[DIVAC+D] ACSEL[AC] DEST[D6] MASK[3]
27m0008 11766 451640007001000030001764	                COND[OBUS<0] SLOOP[VIDDVL] C600 $
27m0008                               	                ;Loop here if remainder positive
27m0008 11767 640310001171000440000000	        D[AR] ACSEL[AC] DEST[O_AC AR] POPJ NORM $
27m0008                               	                ;Swap AR <-> AC and return
27m0008                               	;Q=QUOTIENT,,FRACT
27m0008                               	
27m0008                               	.REPEAT XUCODE [
27m0008                               	        .USE[OTHER]     ;If 8K u-mem present, return to low memory.
27m0008                               	]
27m0008                               	[
27m0008                               	        .USE[OTHER]      [ XLIST
27m0008                               	 LIST ];If 8K u-mem present, return to low memory.
27m0008                               	]
^L
;  <F2-MICROCODE>F2X.LST;13   Mon 5-Jan-81 11:28AM            Page 200


SLOE   Jan ***, 1859 00:00:03  file STRING:  --  of -- f2x

39m0155                               	]VID
39m0155                               	        .OPCODE[766]
39m0155                               	 [XLIST 
39m0156                               	 LIST            ].REPEAT ((1 - VID) * (773 - 766 + 1)) [
39m0156                               	        ILGIOT $                        ;OPS 766:773
39m0156                               	        NOP $
39m0156                               	];1-VID
39m0156                               	.REPEAT VID [
39m0156                               	        ILGIOT $                        ;OP 766 = illegal (reserved)
39m0156                               	        NOP $
39m0156                               	        GETADR[VIDDPA] JUMP[GOHIGH]$    ;OP 767 = DPYADD
39m0156                               	                                        ;Note: GETADR expands to 2 words
39m0156                               	        FIXM2$                          ;OP 770 = VIDIN
39m0156                               	        D[CONST 36] DEST[DEV-ADR] JUMP[VIDIN]$
39m0156                               	        FIXM1$                          ;OP 771 = VIDOUT
39m0156                               	        D[CONST 36] DEST[DEV-ADR] JUMP[VIDOUT]$
39m0156                               	        GETADR[VIDDPI] JUMP[GOHIGH]$    ;OP 772 = DPYINI
39m0156                               	                                        ;Note: GETADR expands to 2 words
39m0156                               	        GETADR[VIDDPO] JUMP[GOHIGH]$    ;OP 773 = DPYOUT
39m0156                               	                                        ;Note: GETADR expands to 2 words
39m0156                               	];[
39m0156                               	        ILGIOT 
39m0156 03754 000140000571000440002026	[  JUMP [MAIN] ]$                       ;OP 766 = illegal (reserved)
39m0156 03755 000700000571000440000000	        NOP $
39m0156                               	        GETADR[VIDDPA]  [  ;Place the 12-bit value of VIDDPA in Q.
39m0156 03756 640700014171014040000000	        D[CONST (77 & (VIDDPA / 100))] ROT[6] DEST[Q] NORM $ ;High-order 6 bits
39m0156 03757 440140014175000540006225	        D[CONST (VIDDPA \ 100)] ALU[DORQ] DEST[Q] C600 ]JUMP[GOHIGH]$   ;OP 767 = DPYADD

39m0156                               	
39m0156                               	                                        ;Note: GETADR expands to 2 words
39m0156 03760 640706200550400440030000	        FIXM2$                          ;OP 770 = VIDIN
39m0156 03761 000141614571000360006246	        D[CONST 36] DEST[DEV-ADR] JUMP[VIDIN]$
39m0156 03762 640706000550400440020000	        FIXM1$                          ;OP 771 = VIDOUT
39m0156 03763 000141614571000360006251	        D[CONST 36] DEST[DEV-ADR] JUMP[VIDOUT]$
39m0156                               	        GETADR[VIDDPI]  [  ;Place the 12-bit value of VIDDPI in Q.
39m0156 03764 640700014171014030000000	        D[CONST (77 & (VIDDPI / 100))] ROT[6] DEST[Q] NORM $ ;High-order 6 bits
39m0156 03765 440140014175000530006225	        D[CONST (VIDDPI \ 100)] ALU[DORQ] DEST[Q] C600 ]JUMP[GOHIGH]$   ;OP 772 = DPYINI

39m0156                               	
39m0156                               	                                        ;Note: GETADR expands to 2 words
39m0156                               	        GETADR[VIDDPO]  [  ;Place the 12-bit value of VIDDPO in Q.
39m0156 03766 640700014171014040000000	        D[CONST (77 & (VIDDPO / 100))] ROT[6] DEST[Q] NORM $ ;High-order 6 bits
39m0156 03767 440140014175000560006225	        D[CONST (VIDDPO \ 100)] ALU[DORQ] DEST[Q] C600 ]JUMP[GOHIGH]$   ;OP 773 = DPYOUT

39m0156                               	
39m0156                               	                                        ;Note: GETADR expands to 2 words
39m0156                               	]VID
39m0156                               	        .RELOC
39m0156                               	 [.USE[OTHER]
39m0156                               	 [ XLIST
39m0157                               	 LIST ]]
39m0157                               	
^L